gisel 0.2.0__py3-none-any.whl

gisel/cli.py

@@ -0,0 +1,238 @@
+"""Command line for the gisel legalizer DSL."""
+
+import argparse
+import difflib
+import json
+import sys
+from pathlib import Path
+
+from . import dsl, td
+from .backend import check_json, core_json, llvm_inc, table
+
+BACKENDS = ("td", "inc", "check", "table", "core")
+
+
+def _table_prefix(source, explicit, gs=None):
+    """-legalizer-table-prefix, defaulted from the source file name.
+
+    tblgen's default is "X86", which is why the AArch64 lane has to pass
+    -legalizer-table-prefix=AArch64.  Deriving it from `X86LegalizerInfo.gisel`
+    removes that footgun; --prefix still overrides.
+    """
+    if explicit:
+        return explicit
+    if gs is not None:
+        for rs in gs.get("rulesets", []):
+            if "_" in rs["def"]:
+                return rs["def"].split("_", 1)[0]
+    stem = Path(source).stem
+    return stem[:-len("LegalizerInfo")] if stem.endswith("LegalizerInfo") else stem
+
+
+def _read_text(path):
+    try:
+        return Path(path).read_text()
+    except OSError as e:
+        print(f"{path}: {e.strerror}", file=sys.stderr)
+        return None
+
+
+def _source_error(source, exc):
+    """`path:line: message`, the shape every editor understands."""
+    msg = str(exc)
+    if msg.startswith("line "):
+        msg = msg[len("line "):]
+    print(f"{source}:{msg}", file=sys.stderr)
+    return 2
+
+
+def _generate(gs, source, emit, prefix=None):
+    if emit == "td":
+        return td.emit_td(gs, source)
+    if emit == "inc":
+        return llvm_inc.emit_inc(gs, source)
+    if emit == "check":
+        return check_json.emit_check(gs)
+    if emit == "table":
+        return table.emit_table(gs, _table_prefix(source, prefix, gs))
+    if emit == "core":
+        return core_json.emit_core(gs, source, Path(source).read_text())
+    raise ValueError(f"unknown backend {emit!r}")
+
+
+def _load_manifest(path):
+    """Bundled table by default; an explicit file may be bare or wrapped."""
+    if not path:
+        return dsl.load_arity_manifest()
+    raw = json.loads(Path(path).read_text())
+    return raw["opcodes"] if "opcodes" in raw else raw
+
+
+def _has_slot(node):
+    if isinstance(node, dict):
+        if node.get("kind") == "slot":
+            return True
+        return any(_has_slot(v) for v in node.values())
+    if isinstance(node, list):
+        return any(_has_slot(v) for v in node)
+    return False
+
+
+def _lint(gs, source, manifest):
+    """J1/J2b/J3a/J3b over every rule, with `.gisel` line numbers."""
+    errors, warnings = [], []
+    nrules = 0
+    for rs in gs["rulesets"]:
+        arities = [manifest.get(o) for o in rs["opcodes"]]
+        known = [a for a in arities if a is not None]
+        arity = min(known) if known else None
+        unknown = [o for o, a in zip(rs["opcodes"], arities) if a is None]
+        first_slot_line = None
+        for rule in rs["rules"]:
+            nrules += 1
+            line = rule.get("_line", 0)
+            errs = []
+            try:
+                dsl.check_rule(rule, arity if arity is not None else 10 ** 9, errs)
+            except (KeyError, IndexError, TypeError, ValueError) as e:
+                errs.append(f"malformed rule: {e}")
+            for msg in errs:
+                errors.append({"file": source, "line": line,
+                               "ruleset": rs["def"], "rule": rule["op"],
+                               "message": msg})
+            if unknown and first_slot_line is None and _has_slot(rule):
+                first_slot_line = line
+        if first_slot_line is not None:
+            warnings.append({"file": source, "line": first_slot_line,
+                             "ruleset": rs["def"],
+                             "message": "arity unknown for %s; slot bounds not checked"
+                                        % ", ".join(unknown)})
+    return errors, warnings, nrules
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    ap = argparse.ArgumentParser(prog="gisel", description=__doc__)
+    ap.add_argument("--version", action="version", version="gisel 0.2.0")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    g = sub.add_parser("gen", help="generate a backend artifact")
+    g.add_argument("source")
+    g.add_argument("--emit", default="td", choices=BACKENDS,
+                   help="backend: td, inc (-gen-legalizer), check (-gen-legalizer-check)")
+    g.add_argument("--out", required=True)
+    g.add_argument("--prefix", help="table prefix (default: from the file name)")
+
+    c = sub.add_parser("check", help="verify a generated artifact is up to date")
+    c.add_argument("source")
+    c.add_argument("--emit", default="td", choices=BACKENDS)
+    c.add_argument("--against", help="artifact to compare against")
+    c.add_argument("--td", help="compatibility alias for --against")
+    c.add_argument("--strict-origin", action="store_true",
+                   help="core: also compare the per-rule origin line numbers")
+
+    b = sub.add_parser("bootstrap", help="build a .gisel from a hand-written .td")
+    b.add_argument("--td", required=True)
+    b.add_argument("--core", required=True)
+    b.add_argument("--out", required=True)
+    b.add_argument("--title", default="Target")
+
+    l = sub.add_parser("lint", help="static checks over a source file (no LLVM)")
+    l.add_argument("source")
+    l.add_argument("--manifest",
+                   help="opcode arity JSON (default: the bundled table)")
+    l.add_argument("--json", action="store_true", help="machine-readable diagnostics")
+    l.add_argument("--max-errors", type=int, default=50,
+                   help="print at most N errors (exit code is unaffected)")
+
+    e = sub.add_parser("eval", help="evaluate the normal form without LLVM")
+    e.add_argument("--doc", required=True)
+    e.add_argument("--features", required=True)
+    e.add_argument("--cases", required=True)
+    e.add_argument("--verbose", action="store_true")
+
+    args = ap.parse_args(argv)
+    if args.cmd == "gen":
+        source_text = _read_text(args.source)
+        if source_text is None:
+            return 2
+        try:
+            gs = td.parse_gisel(source_text)
+            text = _generate(gs, args.source, args.emit, getattr(args, "prefix", None))
+        except ValueError as e:
+            return _source_error(args.source, e)
+        try:
+            Path(args.out).write_text(text)
+        except OSError as e:
+            print(f"{args.out}: {e.strerror}", file=sys.stderr)
+            return 2
+        print(f"{args.out}: {len(gs['rulesets'])} rule sets, "
+              f"{sum(len(r['rules']) for r in gs['rulesets'])} rules")
+        return 0
+    if args.cmd == "check":
+        want_path = args.against or args.td
+        if not want_path:
+            c.error("check needs --against <artifact>")
+        source_text = _read_text(args.source)
+        if source_text is None:
+            return 2
+        try:
+            gs = td.parse_gisel(source_text)
+            got = _generate(gs, args.source, args.emit)
+        except ValueError as e:
+            return _source_error(args.source, e)
+        want = _read_text(want_path)
+        if want is None:
+            return 2
+        if args.emit == "core" and not args.strict_origin:
+            got = core_json.strip_origin(got)
+            want = core_json.strip_origin(want)
+        if got == want:
+            print(f"{want_path}: up to date")
+            return 0
+        sys.stderr.writelines(difflib.unified_diff(
+            want.splitlines(True), got.splitlines(True), want_path, "<generated>"))
+        print(f"{want_path}: STALE (re-run `gisel gen --emit={args.emit}`)",
+              file=sys.stderr)
+        return 1
+    if args.cmd == "lint":
+        text = _read_text(args.source)
+        if text is None:
+            return 2
+        try:
+            gs = td.parse_gisel(text)
+        except ValueError as e:
+            return _source_error(args.source, e)
+        try:
+            manifest = _load_manifest(args.manifest)
+        except (OSError, ValueError, KeyError, json.JSONDecodeError) as e:
+            print(f"{args.manifest}: {e}", file=sys.stderr)
+            return 2
+        errors, warnings, nrules = _lint(gs, args.source, manifest)
+        if args.json:
+            print(json.dumps({"source": args.source,
+                              "errors": errors, "warnings": warnings,
+                              "rules": nrules}, indent=1))
+        else:
+            for e in errors[:args.max_errors]:
+                print(f"{e['file']}:{e['line']}: {e['ruleset']}: "
+                      f"{e['message']}", file=sys.stderr)
+            if len(errors) > args.max_errors:
+                print(f"... {len(errors) - args.max_errors} more error(s)",
+                      file=sys.stderr)
+            for w in warnings:
+                print(f"{w['file']}:{w['line']}: warning: {w['message']}",
+                      file=sys.stderr)
+            print(f"{args.source}: {len(errors)} error(s), {len(warnings)} "
+                  f"warning(s), {nrules} rule(s)")
+        return 1 if errors else 0
+    if args.cmd == "bootstrap":
+        return td.main(["bootstrap", "--td", args.td, "--core", args.core,
+                        "--out", args.out, "--title", args.title])
+    from . import eval as evaluator
+    # `eval` owns its own argument set; drop the subcommand word.
+    return evaluator.main(argv[1:])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gisel/data/generic_opcodes.json

@@ -0,0 +1,290 @@
+{
+ "schema": 1,
+ "source": "llvm/include/llvm/Target/GenericOpcodes.td",
+ "note": "arity = highest (p)typeN index + 1; null = variadic/unknown",
+ "opcodes": {
+  "G_ABDS": 1,
+  "G_ABDU": 1,
+  "G_ABS": 1,
+  "G_ADD": 1,
+  "G_ADDRSPACE_CAST": 2,
+  "G_AND": 1,
+  "G_ANYEXT": 2,
+  "G_ASHR": 2,
+  "G_ASSERT_ALIGN": 1,
+  "G_ASSERT_SEXT": 1,
+  "G_ASSERT_ZEXT": 1,
+  "G_ATOMICRMW_ADD": 2,
+  "G_ATOMICRMW_AND": 2,
+  "G_ATOMICRMW_FADD": 2,
+  "G_ATOMICRMW_FMAX": 2,
+  "G_ATOMICRMW_FMAXIMUM": 2,
+  "G_ATOMICRMW_FMAXIMUMNUM": 2,
+  "G_ATOMICRMW_FMIN": 2,
+  "G_ATOMICRMW_FMINIMUM": 2,
+  "G_ATOMICRMW_FMINIMUMNUM": 2,
+  "G_ATOMICRMW_FSUB": 2,
+  "G_ATOMICRMW_MAX": 2,
+  "G_ATOMICRMW_MIN": 2,
+  "G_ATOMICRMW_NAND": 2,
+  "G_ATOMICRMW_OR": 2,
+  "G_ATOMICRMW_SUB": 2,
+  "G_ATOMICRMW_UDEC_WRAP": 2,
+  "G_ATOMICRMW_UINC_WRAP": 2,
+  "G_ATOMICRMW_UMAX": 2,
+  "G_ATOMICRMW_UMIN": 2,
+  "G_ATOMICRMW_USUB_COND": 2,
+  "G_ATOMICRMW_USUB_SAT": 2,
+  "G_ATOMICRMW_XCHG": 2,
+  "G_ATOMICRMW_XOR": 2,
+  "G_ATOMIC_CMPXCHG": 2,
+  "G_ATOMIC_CMPXCHG_WITH_SUCCESS": 3,
+  "G_BITCAST": 2,
+  "G_BITREVERSE": 1,
+  "G_BLOCK_ADDR": 1,
+  "G_BR": 0,
+  "G_BRCOND": 1,
+  "G_BRINDIRECT": 1,
+  "G_BRJT": 2,
+  "G_BSWAP": 1,
+  "G_BUILD_VECTOR": null,
+  "G_BUILD_VECTOR_TRUNC": null,
+  "G_BZERO": 2,
+  "G_CLMUL": 1,
+  "G_CLMULH": 1,
+  "G_CLMULR": 1,
+  "G_CONCAT_VECTORS": null,
+  "G_CONSTANT": 1,
+  "G_CONSTANT_FOLD_BARRIER": 1,
+  "G_CONSTANT_POOL": 1,
+  "G_CTLS": 2,
+  "G_CTLZ": 2,
+  "G_CTLZ_ZERO_POISON": 2,
+  "G_CTPOP": 2,
+  "G_CTTZ": 2,
+  "G_CTTZ_ZERO_POISON": 2,
+  "G_DEBUGTRAP": 0,
+  "G_DYN_STACKALLOC": 2,
+  "G_EXTRACT": 2,
+  "G_EXTRACT_SUBVECTOR": 2,
+  "G_EXTRACT_VECTOR_ELT": 3,
+  "G_FABS": 1,
+  "G_FACOS": 1,
+  "G_FADD": 1,
+  "G_FASIN": 1,
+  "G_FATAN": 1,
+  "G_FATAN2": 1,
+  "G_FCANONICALIZE": 1,
+  "G_FCEIL": 1,
+  "G_FCMP": 2,
+  "G_FCONSTANT": 1,
+  "G_FCOPYSIGN": 2,
+  "G_FCOS": 1,
+  "G_FCOSH": 1,
+  "G_FDIV": 1,
+  "G_FENCE": 0,
+  "G_FEXP": 1,
+  "G_FEXP10": 1,
+  "G_FEXP2": 1,
+  "G_FFLOOR": 1,
+  "G_FFREXP": 2,
+  "G_FLDEXP": 2,
+  "G_FLOG": 1,
+  "G_FLOG10": 1,
+  "G_FLOG2": 1,
+  "G_FMA": 1,
+  "G_FMAD": 1,
+  "G_FMAXIMUM": 1,
+  "G_FMAXIMUMNUM": 1,
+  "G_FMAXNUM": 1,
+  "G_FMAXNUM_IEEE": 1,
+  "G_FMINIMUM": 1,
+  "G_FMINIMUMNUM": 1,
+  "G_FMINNUM": 1,
+  "G_FMINNUM_IEEE": 1,
+  "G_FMODF": 1,
+  "G_FMUL": 1,
+  "G_FNEARBYINT": 1,
+  "G_FNEG": 1,
+  "G_FPEXT": 2,
+  "G_FPEXTLOAD": 2,
+  "G_FPOW": 1,
+  "G_FPOWI": 2,
+  "G_FPTOSI": 2,
+  "G_FPTOSI_SAT": 2,
+  "G_FPTOUI": 2,
+  "G_FPTOUI_SAT": 2,
+  "G_FPTRUNC": 2,
+  "G_FPTRUNCSTORE": 2,
+  "G_FRAME_INDEX": 1,
+  "G_FREEZE": 1,
+  "G_FREM": 1,
+  "G_FRINT": 1,
+  "G_FSHL": 2,
+  "G_FSHR": 2,
+  "G_FSIN": 1,
+  "G_FSINCOS": 1,
+  "G_FSINH": 1,
+  "G_FSQRT": 1,
+  "G_FSUB": 1,
+  "G_FTAN": 1,
+  "G_FTANH": 1,
+  "G_GET_FPENV": 1,
+  "G_GET_FPMODE": 1,
+  "G_GET_ROUNDING": 1,
+  "G_GLOBAL_VALUE": 1,
+  "G_ICMP": 2,
+  "G_IMPLICIT_DEF": 1,
+  "G_INDEXED_LOAD": 3,
+  "G_INDEXED_SEXTLOAD": 3,
+  "G_INDEXED_STORE": 3,
+  "G_INDEXED_ZEXTLOAD": 3,
+  "G_INSERT": 2,
+  "G_INSERT_SUBVECTOR": 2,
+  "G_INSERT_VECTOR_ELT": 3,
+  "G_INTRINSIC": null,
+  "G_INTRINSIC_CONVERGENT": null,
+  "G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS": null,
+  "G_INTRINSIC_FPTRUNC_ROUND": 2,
+  "G_INTRINSIC_LLRINT": 2,
+  "G_INTRINSIC_LRINT": 2,
+  "G_INTRINSIC_ROUND": 1,
+  "G_INTRINSIC_ROUNDEVEN": 1,
+  "G_INTRINSIC_TRUNC": 1,
+  "G_INTRINSIC_W_SIDE_EFFECTS": null,
+  "G_INTTOPTR": 2,
+  "G_INVOKE_REGION_START": 0,
+  "G_IS_FPCLASS": 2,
+  "G_JUMP_TABLE": 1,
+  "G_LLROUND": 2,
+  "G_LOAD": 2,
+  "G_LROUND": 2,
+  "G_LSHR": 2,
+  "G_MEMCPY": 3,
+  "G_MEMCPY_INLINE": 3,
+  "G_MEMMOVE": 3,
+  "G_MEMSET": 3,
+  "G_MEMSET_INLINE": 3,
+  "G_MERGE_VALUES": null,
+  "G_MUL": 1,
+  "G_OR": 1,
+  "G_PHI": null,
+  "G_PREFETCH": 1,
+  "G_PTRAUTH_GLOBAL_VALUE": 2,
+  "G_PTRMASK": 2,
+  "G_PTRTOINT": 2,
+  "G_PTR_ADD": 2,
+  "G_READCYCLECOUNTER": 1,
+  "G_READSTEADYCOUNTER": 1,
+  "G_READ_REGISTER": 1,
+  "G_RESET_FPENV": 0,
+  "G_RESET_FPMODE": 0,
+  "G_ROTL": 2,
+  "G_ROTR": 2,
+  "G_SADDE": 2,
+  "G_SADDO": 2,
+  "G_SADDSAT": 1,
+  "G_SAVGCEIL": 1,
+  "G_SAVGFLOOR": 1,
+  "G_SBFX": 2,
+  "G_SCMP": 2,
+  "G_SDIV": 1,
+  "G_SDIVFIX": 1,
+  "G_SDIVFIXSAT": 1,
+  "G_SDIVREM": 1,
+  "G_SELECT": 2,
+  "G_SET_FPENV": 1,
+  "G_SET_FPMODE": 1,
+  "G_SET_ROUNDING": 1,
+  "G_SEXT": 2,
+  "G_SEXTLOAD": 2,
+  "G_SEXT_INREG": 1,
+  "G_SHL": 2,
+  "G_SHUFFLE_VECTOR": 2,
+  "G_SITOFP": 2,
+  "G_SMAX": 1,
+  "G_SMIN": 1,
+  "G_SMULFIX": 1,
+  "G_SMULFIXSAT": 1,
+  "G_SMULH": 1,
+  "G_SMULO": 2,
+  "G_SPLAT_VECTOR": 2,
+  "G_SREM": 1,
+  "G_SSHLSAT": 2,
+  "G_SSUBE": 2,
+  "G_SSUBO": 2,
+  "G_SSUBSAT": 1,
+  "G_STACKRESTORE": 1,
+  "G_STACKSAVE": 1,
+  "G_STEP_VECTOR": 1,
+  "G_STORE": 2,
+  "G_STRICT_FADD": 0,
+  "G_STRICT_FCMP": 0,
+  "G_STRICT_FCMPS": 0,
+  "G_STRICT_FDIV": 0,
+  "G_STRICT_FLDEXP": 0,
+  "G_STRICT_FMA": 0,
+  "G_STRICT_FMUL": 0,
+  "G_STRICT_FREM": 0,
+  "G_STRICT_FSQRT": 0,
+  "G_STRICT_FSUB": 0,
+  "G_SUB": 1,
+  "G_TRAP": 0,
+  "G_TRUNC": 2,
+  "G_TRUNC_SSAT_S": 2,
+  "G_TRUNC_SSAT_U": 2,
+  "G_TRUNC_USAT_U": 2,
+  "G_UADDE": 2,
+  "G_UADDO": 2,
+  "G_UADDSAT": 1,
+  "G_UAVGCEIL": 1,
+  "G_UAVGFLOOR": 1,
+  "G_UBFX": 2,
+  "G_UBSANTRAP": 0,
+  "G_UCMP": 2,
+  "G_UDIV": 1,
+  "G_UDIVFIX": 1,
+  "G_UDIVFIXSAT": 1,
+  "G_UDIVREM": 1,
+  "G_UITOFP": 2,
+  "G_UMAX": 1,
+  "G_UMIN": 1,
+  "G_UMULFIX": 1,
+  "G_UMULFIXSAT": 1,
+  "G_UMULH": 1,
+  "G_UMULO": 2,
+  "G_UNMERGE_VALUES": null,
+  "G_UREM": 1,
+  "G_USHLSAT": 2,
+  "G_USUBE": 2,
+  "G_USUBO": 2,
+  "G_USUBSAT": 1,
+  "G_VAARG": 2,
+  "G_VASTART": 1,
+  "G_VECREDUCE_ADD": 2,
+  "G_VECREDUCE_AND": 2,
+  "G_VECREDUCE_FADD": 2,
+  "G_VECREDUCE_FMAX": 2,
+  "G_VECREDUCE_FMAXIMUM": 2,
+  "G_VECREDUCE_FMAXIMUMNUM": 2,
+  "G_VECREDUCE_FMIN": 2,
+  "G_VECREDUCE_FMINIMUM": 2,
+  "G_VECREDUCE_FMINIMUMNUM": 2,
+  "G_VECREDUCE_FMUL": 2,
+  "G_VECREDUCE_MUL": 2,
+  "G_VECREDUCE_OR": 2,
+  "G_VECREDUCE_SEQ_FADD": 3,
+  "G_VECREDUCE_SEQ_FMUL": 3,
+  "G_VECREDUCE_SMAX": 2,
+  "G_VECREDUCE_SMIN": 2,
+  "G_VECREDUCE_UMAX": 2,
+  "G_VECREDUCE_UMIN": 2,
+  "G_VECREDUCE_XOR": 2,
+  "G_VECTOR_COMPRESS": 2,
+  "G_VSCALE": 1,
+  "G_WRITE_REGISTER": 1,
+  "G_XOR": 1,
+  "G_ZEXT": 2,
+  "G_ZEXTLOAD": 2
+ }
+}