@asmlift/core 0.9.0 → 0.10.0

package/src/ir/opcodes.ts

@@ -38,7 +38,14 @@ export const OPCODES = {
   // Effect-free (no `effects` flag) so DCE reaps a dead one.
   mulh: { operands: 2, results: 1 },
   mulhu: { operands: 2, results: 1 },
-  neg: { operands: 1, results: 1 },
+  neg: { operands: 1, results: 1 }, // the wrapping negation, 0 - x as a 32-bit word
+  // The MATHEMATICAL negation: what Thumb's `cmn rA, rB` compares rA against when a signed branch
+  // reads it (frontend/thumb.ts `lowerTerminator`). It differs from `neg` at exactly one operand,
+  // 0x80000000, where its value (+2^31) is no 32-bit word at all. A separate opcode rather than an
+  // attr on `neg` because every word evaluator in core folds `neg` as the wrapping one, and an
+  // attr each of them must remember to read fails OPEN: one that does not know `neg_s` falls to
+  // its default arm and declines. Only the structurer spells it, as `-(s32)x`.
+  neg_s: { operands: 1, results: 1 },
   not: { operands: 1, results: 1 }, // bitwise complement (`mvn`) → ~x
   or: { operands: 2, results: 1 },
   and: { operands: 2, results: 1 },
@@ -151,6 +158,32 @@ export const OPCODES = {
   // opcode rather than a `const` over a float type for the reason the arithmetic above has its own:
   // every pass that matches `const` is an integer fold.
   fconst: { operands: 0, results: 1, requiredAttrs: ['bits'] },
+  // The CROSSINGS between a float and an integer, C's conversions: `fptosi`/`fptoui` truncate toward
+  // zero into a signed or unsigned integer of the result's width (32 or 64), `sitofp` converts a
+  // signed one, `fpext`/`fptrunc` move between the precisions. The only ops a float and an integer
+  // meet in (ir/verify.ts). No `uitofp`: no compiler here converts an unsigned integer in one step
+  // (agbcc open-codes it around `__floatsisf`), so it would be an opcode with no producer.
+  fptosi: { operands: 1, results: 1 },
+  fptoui: { operands: 1, results: 1 },
+  sitofp: { operands: 1, results: 1 },
+  fpext: { operands: 1, results: 1 },
+  fptrunc: { operands: 1, results: 1 },
+  // The float COMPARES, a 0/1 integer out of two floats of one type. Ten and not six, because
+  // NaN makes C's relations a partial order: `!(a > b)` is true on a NaN and `a <= b` is not, and
+  // every compiler here compiles the two differently. So each ordered relation (`o`, false on a
+  // NaN) has its logical negation as an unordered opcode (`u`, true on a NaN): `fcmp_ule` IS
+  // `!(a > b)`. C's `!=` is `fcmp_une`. They stay out of `NEGATED_ICMP`, whose integer negation
+  // (`<` ↔ `>=`) would be the wrong program here; `NEGATED_FCMP` below is theirs.
+  fcmp_oeq: { operands: 2, results: 1 },
+  fcmp_une: { operands: 2, results: 1 },
+  fcmp_olt: { operands: 2, results: 1 },
+  fcmp_uge: { operands: 2, results: 1 },
+  fcmp_ole: { operands: 2, results: 1 },
+  fcmp_ugt: { operands: 2, results: 1 },
+  fcmp_ogt: { operands: 2, results: 1 },
+  fcmp_ule: { operands: 2, results: 1 },
+  fcmp_oge: { operands: 2, results: 1 },
+  fcmp_ult: { operands: 2, results: 1 },
   // --- memory ---
   load: { operands: 1, results: 1, requiredAttrs: ['off', 'width', 'signed'], reads: true },
   store: { operands: 2, results: 0, requiredAttrs: ['off', 'width'], effects: true },
@@ -214,13 +247,16 @@ export const OPCODES = {
   // live-in, and a live-in of the entry block is a PARAMETER — right for an argument register, a
   // fabricated argument for anything else.
   //
-  // Operand-free and pure like `laddr`, and out of raise/gvn.ts's NUMBERABLE set — where numbering
-  // it would be VACUOUS rather than harmful, since two undefs in one function always carry
-  // different keys. "Same key, therefore same value" is empty for a value that has none.
+  // Operand-free and pure like `laddr`, and out of raise/gvn.ts's NUMBERABLE set, which must keep
+  // it out: two undefs of one key are a storage's content and a `copied` move of it, and numbering
+  // them one value would erase the move.
   //
   // `key` names the storage (`sp@0`, `r4`); the structurer reads it to name the local
   // (`uninit_sp0`) and emits NO assignment — that absence is the recovery, and an edge argument
-  // that is one emits no copy either (structure.ts undefCarriesNothing).
+  // that is one emits no copy either (structure.ts undefCarriesNothing). OPTIONAL `copied: true`:
+  // the value another storage's content arrives at a join keyed elsewhere as (`if (c) x = y;` of
+  // two uninitialised locals, frontend/ssa.ts `markCopiedUndefs`) — the machine moved it, so that
+  // edge copy IS emitted, under the name of the undef its key names.
   undef: { operands: 0, results: 1, requiredAttrs: ['key'] },
   // --- black-box escape hatch (keeps lifting total) ---
   // `effects: true`: an instruction asmlift could not model may do anything — write memory, trap,
@@ -243,6 +279,11 @@ export const OPCODES = {
   // Many-way switch dispatch (Regime B, jump table). The single operand is the scrutinee;
   // successors are the N case blocks followed by the default block (the LAST successor);
   // `cases` is the index-aligned list of the first N successors' case values.
+  // `exhaustive: true` — OPTIONAL, set by a frontend whose dispatch block is entered only past a
+  // bounds test that already sent every value outside `cases` elsewhere, so the default edge is
+  // never taken. It still names a block, because the op needs a last successor; the structurer
+  // reads the attr to emit no `default:` arm for it. A pass that rebuilds the op leaves it off and
+  // gets the default arm back, which is the conservative answer.
   switch_br: { operands: 1, results: 0, terminator: true, successors: 'variadic', requiredAttrs: ['cases'] },
 } as const satisfies Record<string, OpSig>;
 
@@ -272,6 +313,65 @@ export const CAST_WIDTHS: ReadonlySet<number> = new Set([8, 16]);
  *  an op computes ON. */
 export const FLOAT_OPS: ReadonlySet<string> = new Set(['fadd', 'fsub', 'fmul', 'fdiv', 'fneg', 'fconst']);
 
+/** The conversions out of a float into an integer, and into a float out of an integer. */
+export const FLOAT_TO_INT: ReadonlySet<string> = new Set(['fptosi', 'fptoui']);
+export const INT_TO_FLOAT: ReadonlySet<string> = new Set(['sitofp']);
+/** The conversions between the two precisions, each named by the width it converts from and to. */
+export const FLOAT_RESIZE: Readonly<Record<string, { from: 32 | 64; to: 32 | 64 }>> = {
+  fpext: { from: 32, to: 64 },
+  fptrunc: { from: 64, to: 32 },
+};
+
+/** The logical negation of each float compare, NaN included (the registry's note on `fcmp_*`):
+ *  expanded both ways from the pairs, as `NEGATED_ICMP` is. */
+const FCMP_NEGATION_PAIRS: readonly (readonly [Opcode, Opcode])[] = [
+  ['fcmp_oeq', 'fcmp_une'],
+  ['fcmp_olt', 'fcmp_uge'],
+  ['fcmp_ole', 'fcmp_ugt'],
+  ['fcmp_ogt', 'fcmp_ule'],
+  ['fcmp_oge', 'fcmp_ult'],
+];
+export const NEGATED_FCMP: Readonly<Record<string, Opcode>> = Object.fromEntries(
+  FCMP_NEGATION_PAIRS.flatMap(([a, b]) => [
+    [a, b],
+    [b, a],
+  ]),
+);
+
+/** What each float compare answers when its first operand is LESS than, EQUAL to or GREATER than
+ *  its second, and when the two are UNORDERED (either is a NaN): the definition of the ten, from
+ *  which a compare a runtime computes some other way is read (raise/floathelpers.ts). */
+export const FCMP_TRUTH: Readonly<Record<string, readonly [lt: boolean, eq: boolean, gt: boolean, un: boolean]>> = {
+  fcmp_olt: [true, false, false, false],
+  fcmp_ole: [true, true, false, false],
+  fcmp_ogt: [false, false, true, false],
+  fcmp_oge: [false, true, true, false],
+  fcmp_oeq: [false, true, false, false],
+  fcmp_une: [true, false, true, true],
+  fcmp_uge: [false, true, true, true],
+  fcmp_ugt: [false, false, true, true],
+  fcmp_ule: [true, true, false, true],
+  fcmp_ult: [true, false, false, true],
+};
+
+/** The float compare whose truth table (`FCMP_TRUTH`'s order: less, equal, greater, unordered) is
+ *  `truth`, or undefined where none is — always true, say. The one reader of the table backwards,
+ *  for every place that computes a compare's answers some other way (agbcc's helper tests,
+ *  raise/floathelpers.ts; PowerPC's `cror` of two bits, frontend/ppc.ts). */
+export function fcmpOfTruth(truth: readonly boolean[]): Opcode | undefined {
+  return Object.keys(FCMP_TRUTH).find((k) => FCMP_TRUTH[k].every((t, i) => t === truth[i])) as Opcode | undefined;
+}
+
+/** Every op that computes on a float: the arithmetic, the conversions and the compares. A runtime
+ *  helper whose op is one of these is a float helper (runtime-helpers.ts `isFloatHelper`). */
+export const FLOAT_COMPUTING: ReadonlySet<string> = new Set([
+  ...FLOAT_OPS,
+  ...FLOAT_TO_INT,
+  ...INT_TO_FLOAT,
+  ...Object.keys(FLOAT_RESIZE),
+  ...Object.keys(NEGATED_FCMP),
+]);
+
 /** Signature lookup by RUNTIME opcode string (Op.opcode is a plain string — IR consumers switch
  *  on it); undefined for an unregistered opcode. */
 export function opSig(opcode: string): OpSig | undefined {
@@ -290,10 +390,10 @@ export function opSig(opcode: string): OpSig | undefined {
  *
  *  It lives here so that every consumer that has to say "the opposite of this compare" reads THIS
  *  one, and they cannot drift apart the way inline copies did. Two adjacent facts worth knowing: raise/
- *  shortcircuit.ts derives its `BOOL_OPS` from these keys (asserting negatable-icmp == boolean-op,
- *  true today), and l3/ast.ts `NEGATE_REL` is the SAME relation over the neutral L3 operator
- *  vocabulary — deliberately separate, because signedness lives in the operand types there, so the
- *  two tables are not candidates for further consolidation. */
+ *  shortcircuit.ts derives its `BOOL_OPS` from these keys and `NEGATED_FCMP`'s (asserting
+ *  negatable compare == boolean-op, true today), and l3/ast.ts `NEGATE_REL` is the SAME relation
+ *  over the neutral L3 operator vocabulary — deliberately separate, because signedness lives in the
+ *  operand types there, so the two tables are not candidates for further consolidation. */
 const ICMP_NEGATION_PAIRS: readonly (readonly [Opcode, Opcode])[] = [
   ['icmp_eq', 'icmp_ne'],
   ['icmp_slt', 'icmp_sge'],

package/src/ir/types.ts

@@ -7,6 +7,11 @@ export interface StructField {
   off: number;
   type: IrType;
   name: string;
+  /** A cell the function also reads or writes at another width or extension, declared at its
+   *  widest view because the union of its views would not fit the compiler's layout
+   *  (raise/structs.ts `buildUnionStruct`). An access of any other type is a cast of the base
+   *  (structure.ts `memAccess`). */
+  castViews?: true;
 }
 
 export type IrType =
@@ -93,6 +98,31 @@ export const T = {
   void: (): IrType => ({ kind: 'void' }),
 };
 
+/** The member name of each view a union holds, by access width. A width with no entry has no view
+ *  (the deref contract admits no other scalar width either), and its overlap still declines. A
+ *  narrow width loaded with both extensions has a view per extension, `u`/`s` prefixed. */
+export const UNION_VIEW_NAMES: Readonly<Record<number, string>> = { 1: 'byte', 2: 'half', 4: 'word' };
+
+/** The extensions a union declares a view of `width` bytes in, from the accesses of that width:
+ *  THE one rule raise/structs.ts `buildUnionStruct` and the frame audit (frontend/frame-objects.ts
+ *  `unionViews`) both declare by, so a struct member's union and a frame object's cannot disagree
+ *  on their views. A word has one view whatever its loads say (`scalarTypeForAccess`); a narrower
+ *  width a view per extension it is LOADED with, unsigned first; a width only stored the signed
+ *  view where a stamped store says signed (raise/storesign.ts) and the unsigned one otherwise. */
+export function unionViewSigns(
+  width: number,
+  accesses: readonly { readonly isLoad: boolean; readonly signed: boolean; readonly stamped: boolean }[],
+): boolean[] {
+  if (width === 4) {
+    return [true];
+  }
+  const loaded = new Set(accesses.filter((a) => a.isLoad).map((a) => a.signed));
+  if (loaded.size === 0) {
+    return [accesses.some((a) => a.stamped && a.signed)];
+  }
+  return [false, true].filter((sg) => loaded.has(sg));
+}
+
 /** The byte width of a union view's element (an array view's element, or the scalar itself). */
 function viewBytes(t: IrType): number {
   const e = t.kind === 'array' ? t.elem : t;
@@ -102,6 +132,11 @@ function viewBytes(t: IrType): number {
   return e.width / 8;
 }
 
+/** A struct as its declaration spells it (`declared`), else by its tag; any other type as printed. */
+export function structSpelling(t: IrType): string {
+  return t.kind === 'struct' ? (t.declared ?? `struct ${t.name}`) : typeToString(t);
+}
+
 /** The member `name` of an aggregate — a struct's field or a union's view — or undefined when `t`
  *  is not an aggregate or declares no such member. THE one lookup the typing walk and the deref
  *  contract share, so the two cannot disagree on which member access is well-typed. */
@@ -131,8 +166,57 @@ export function unionViewAt(
   if (member === undefined || member.type.kind !== 'union') {
     return undefined;
   }
+  return { member, ...unionView(member.type, off - member.off, width, signed, isStore) };
+}
+
+/** Does a member declared at signedness `declared` read as EXACTLY the type the cast spelling this
+ *  replaces would have produced — `scalarTypeForAccess(width, signed)`? That is the whole
+ *  byte-exactness argument for naming a member instead of casting: same address, same read width,
+ *  same C type, so every operator downstream compiles identically. A 4-byte access renders s32
+ *  whatever the load said (the ISA has one word load), so only a SIGNED member may take its place;
+ *  narrower accesses carry their own signedness and must match it. An undeclared signedness (the
+ *  member is not a base type — a nested struct, an enum, a pointer) is never assumed to match.
+ *  THE one copy of "an access names the member": structure.ts's member spellings and `isCastView`
+ *  below all ask it, so they cannot drift apart. */
+export function spellsAccessType(declared: boolean | undefined, width: number, signed: boolean): boolean {
+  if (declared === undefined) {
+    return false;
+  }
+  return typeEquals(T.int(width * 8, declared), scalarTypeForAccess(width, signed));
+}
+
+/** Does an access of `width` bytes at byte `off`, inside a `castViews` field of the struct, read it
+ *  at a view other than the field's own type — another width or offset, or a load whose type the
+ *  field does not spell (`spellsAccessType`)? A store carries no extension (it truncates to the
+ *  field's bytes whatever their type), so one of the field's width at its offset is the field. */
+export function isCastView(
+  st: Extract<IrType, { kind: 'struct' }>,
+  off: number,
+  width: number,
+  signed: boolean,
+  isStore: boolean,
+): boolean {
+  const f = st.fields.find(
+    (m) => m.castViews === true && m.off <= off && off + width <= m.off + (intWidth(m.type) ?? 0) / 8,
+  );
+  if (f === undefined || f.type.kind !== 'int') {
+    return false;
+  }
+  return off !== f.off || f.type.width !== width * 8 || (!isStore && !spellsAccessType(f.type.signed, width, signed));
+}
+
+/** The view of a union an access of `width` bytes at byte `at` of it reads — the rule
+ *  `unionViewAt` states, asked of a union that is not a struct's member (a frame object declared
+ *  as one, structure.ts `laddrType`). */
+export function unionView(
+  u: Extract<IrType, { kind: 'union' }>,
+  at: number,
+  width: number,
+  signed: boolean,
+  isStore: boolean,
+): { view: StructField | undefined; index: number | null } {
   const elemOf = (t: IrType): IrType => (t.kind === 'array' ? t.elem : t);
-  const wide = member.type.members.filter((m) => intWidth(elemOf(m.type)) === width * 8);
+  const wide = u.members.filter((m) => intWidth(elemOf(m.type)) === width * 8);
   const signOf = (m: StructField): boolean | undefined => {
     const e = elemOf(m.type);
     return e.kind === 'int' ? e.signed : undefined;
@@ -141,7 +225,7 @@ export function unionViewAt(
     width === 4 || (isStore && wide.length === 1)
       ? wide[0]
       : wide.find((m) => signOf(m) === (isStore ? false : signed));
-  return { member, view, index: view?.type.kind === 'array' ? (off - member.off) / width : null };
+  return { view, index: view?.type.kind === 'array' ? at / width : null };
 }
 
 export function typeToString(t: IrType): string {

package/src/ir/verify.ts

@@ -3,30 +3,57 @@
 //   1. every block ends in exactly one terminator (and it is the last op)
 //   2. operands well-formed: opcode registered, correct arity/attrs
 //   3. SSA: each value defined once; every use is defined; def dominates use
-//   4. a float value is an operand or result of a float op or `ret` only — or a `double` operand of
-//      a call whose callee declares one there — and crosses an edge only into a block parameter of
-//      its own type; an `fconst` is a double, sixteen hex digits into an f64
+//   4. a float value is an operand or result of a float op, a conversion or a compare, or `ret` only
+//      — or a `double` operand of a call whose callee declares one there, or the result of a call
+//      whose callee is declared to return a `float` — and crosses an edge only
+//      into a block parameter of its own type; an `fconst` is a double, sixteen hex digits into an f64
 //   5. side data: a fn that carries a write-order record carries one for EVERY block, with every
 //      ordinal inside that block's own write count (ir/core.ts `WriteOrder`)
 import { Block, Fn, Op, Value, dominators } from './core';
 import { isDoubleBits } from './float-bits';
-import { FLOAT_OPS, WIDE_BITS, opSig } from './opcodes';
+import { FLOAT_COMPUTING, FLOAT_OPS, FLOAT_RESIZE, FLOAT_TO_INT, INT_TO_FLOAT, WIDE_BITS, opSig } from './opcodes';
 import { type IrType, T, intWidth, typeEquals, typeToString } from './types';
 
 export class VerifyError extends Error {}
 
 /** A call hands a float only to a parameter its callee is declared to take a `double` in — the
- *  operands the frontend lists in `doubles` — and returns none. */
-function doublesDeclared(op: Op): boolean {
-  const at = op.attrs.doubles;
+ *  operands the frontend lists in `doubles` — and returns one only where its callee is declared to
+ *  return a `float` (`floatReturn`), as that single. */
+function floatsDeclared(op: Op): boolean {
+  const at = Array.isArray(op.attrs.doubles) ? op.attrs.doubles : [];
   return (
     op.opcode === 'call' &&
-    Array.isArray(at) &&
-    op.results.every((r) => r.type.kind !== 'float') &&
+    op.results.every(
+      (r) => r.type.kind !== 'float' || (op.attrs.floatReturn === 'float' && typeEquals(r.type, T.f32())),
+    ) &&
     op.operands.every((o, i) => o.type.kind !== 'float' || (at.includes(i) && typeEquals(o.type, T.f64())))
   );
 }
 
+/** The ops where a float meets an integer or the other precision, each held to the one shape it
+ *  has: a conversion takes a float of either stated precision or none and gives an integer, or the
+ *  reverse; a resize takes its own source width to its own destination width; a compare takes two
+ *  floats of one type and gives a 32-bit integer. The integer side may be narrower than a word once
+ *  recovery has typed it (`(float)x` of a `short` parameter), which converts the value it promotes
+ *  to; the C spelling casts through `s32`/`s64`. */
+function verifyFloatCrossing(op: Op): void {
+  const ins = op.operands.map((o) => o.type);
+  const out = op.results[0].type;
+  const isInt = (t: IrType) => intWidth(t) !== null;
+  const resize = FLOAT_RESIZE[op.opcode];
+  const ok = FLOAT_TO_INT.has(op.opcode)
+    ? ins[0].kind === 'float' && isInt(out)
+    : INT_TO_FLOAT.has(op.opcode)
+      ? isInt(ins[0]) && out.kind === 'float'
+      : resize !== undefined
+        ? typeEquals(ins[0], resize.from === 64 ? T.f64() : T.f32()) &&
+          typeEquals(out, resize.to === 64 ? T.f64() : T.f32())
+        : ins[0].kind === 'float' && typeEquals(ins[0], ins[1]) && intWidth(out) === 32;
+  if (!ok) {
+    throw new VerifyError(`'${op.opcode}' does not take ${ins.map(typeToString).join(', ')} to ${typeToString(out)}`);
+  }
+}
+
 // Opcodes admitting EITHER a 2-operand register form OR a 1-operand + `imm` attr form.
 const TWO_OR_IMM = new Set(['sdiv', 'shl', 'shr_u', 'shr_s']);
 
@@ -41,7 +68,21 @@ const TWO_OR_IMM = new Set(['sdiv', 'shl', 'shr_u', 'shr_s']);
 // `unknown` PARTICIPATES, and that is the whole point: at L1 every value is `unknown`, so a rule
 // that skipped it would be vacuous exactly where this is meant to be red. The shifts count only
 // their SHIFTED operand — a 64-bit shift by a 32-bit count is what the machine does.
-const WIDTH_UNIFORM = new Set(['add', 'sub', 'mul', 'and', 'or', 'xor', 'neg', 'not', 'sdiv', 'udiv', 'smod', 'umod']);
+const WIDTH_UNIFORM = new Set([
+  'add',
+  'sub',
+  'mul',
+  'and',
+  'or',
+  'xor',
+  'neg',
+  'neg_s',
+  'not',
+  'sdiv',
+  'udiv',
+  'smod',
+  'umod',
+]);
 // The shifts count only their SHIFTED operand: a 64-bit value shifted by a 32-bit count is what
 // every one of these machines does. The comparisons count only their OPERANDS: the result of a C
 // comparison is an `int` whatever it compared, which is what `raise/recover.ts` already types it.
@@ -181,6 +222,32 @@ export function verify(fn: Fn): void {
                   `got width ${String(op.attrs.width)}, signed ${String(op.attrs.signed)}`,
               );
             }
+            // …and a PART of the one object (frame-objects.ts `provenParts`) is such storage too
+            if (op.attrs.part !== undefined && op.attrs.part !== true) {
+              throw new VerifyError(`'laddr' part must be true, got ${String(op.attrs.part)}`);
+            }
+            if (op.attrs.part === true && count < 2) {
+              throw new VerifyError(`'laddr' part must be storage of two or more bytes, got ${count}`);
+            }
+            // …and storage accessed at two widths over one byte names the VIEWS a union of it
+            // declares (frame-objects.ts `unionViews`): one per element width in bytes, negative
+            // for a signed narrow one, each tiling the storage — so at least two, distinct, of a
+            // width a view is named for, and a word never signed-marked (it has one view).
+            const views = op.attrs.views;
+            if (views !== undefined) {
+              const ok =
+                Array.isArray(views) &&
+                count > 1 &&
+                views.length >= 2 &&
+                new Set(views).size === views.length &&
+                views.every((v) => [1, 2, 4, -1, -2].includes(v) && count % Math.abs(v) === 0);
+              if (!ok) {
+                throw new VerifyError(
+                  `'laddr' views must be two or more distinct element widths (1, 2, 4; negative for a signed ` +
+                    `narrow view) tiling its ${String(count)} bytes, got ${JSON.stringify(views)}`,
+                );
+              }
+            }
           }
           // A 64-bit value is BUILT and TAKEN APART by exactly these three, so their shape is
           // checked here rather than left to whoever reads a half. `concat` is the only producer.
@@ -223,7 +290,9 @@ export function verify(fn: Fn): void {
             if (floats.length !== all.length || all.some((t) => !typeEquals(t, all[0]))) {
               throw new VerifyError(`'${op.opcode}' computes on floats only, got ${all.map(typeToString).join(', ')}`);
             }
-          } else if (floats.length > 0 && op.opcode !== 'ret' && !doublesDeclared(op)) {
+          } else if (FLOAT_COMPUTING.has(op.opcode)) {
+            verifyFloatCrossing(op);
+          } else if (floats.length > 0 && op.opcode !== 'ret' && !floatsDeclared(op)) {
             throw new VerifyError(`a float value reaches '${op.opcode}', which does not compute on floats`);
           }
           // A literal's width is its pattern's, so the pattern and the result must name one width.