{"entries":[{"file_sha256":"bfc1e646e91fe0ba6d7d16e43994100b05c3b8ff79c2e07288e8955c43d9d79d","kind":"documentation_input","lines":"1018-1034","path":"docs/spec-compiler-part-2-scf.md","roles":["input_construction","input_well_formedness","applicability"],"text":"The current Structured ExecutionShape generator consumes a finite set of exact\nStructured Program references. An empty input set produces an empty output\nset. A parent with no unresolved selected-Spatial execution-shape choice passes\nthrough unchanged. A parent containing an unresolved, exactly representable\n`llvm.intr.fmuladd` emits the canonical pair of complete Structured children:\n\n```text\nFused -> math.fma\nSplit -> arith.mulf followed by arith.addf\n```\n\nOne decision applies uniformly to every unresolved `fmuladd` in the selected\nSpatial ownership of that complete parent. It never rewrites residual\nInstructionCore operations or operations owned by nested callables. This is a\ntwo-element semantic policy domain, not one independent Boolean dimension per\noperation. Distinct per-operation combinations are not part of the current\ncontract.","why":"Normative input conditions of the Structured ExecutionShape generator: a finite set of Structured Program references, an empty input set, a parent with no unresolved choice, a parent owning an unresolved exactly representable llvm.intr.fmuladd, the two-element Fused/Split policy domain applied uniformly to every unresolved fmuladd of one parent, and the exclusion of residual InstructionCore operations and operations owned by nested callables. Determines the sampled module shapes (empty module, resolved parent, plain parent with one or two fmuladds, nested callable) and the per-callable slot scoping of the postcondition."},{"file_sha256":"bfc1e646e91fe0ba6d7d16e43994100b05c3b8ff79c2e07288e8955c43d9d79d","kind":"documentation_input","lines":"1036-1044","path":"docs/spec-compiler-part-2-scf.md","roles":["context"],"text":"Each child preserves the exact floating type, fast-math contract, source\nlocation, Ownership lineage, and source-provenance projection. It is verified\nand finalized through the sole Structured Program finalizer before publication\nto the output set. Schedule and MemoryCommunication may then form further\ncomplete Structured children. The terminal SpecialMathAccuracy generator is\nthe selected-Spatial semantic-closure gate that first lowers the final complete\ncandidate to D0 and checks exact concrete Fabric admission. No unresolved\nparent, mixed Fused/Split child, hidden backend default, or\ntarget-code-generation choice may cross the ExecutionShape boundary.","why":"Governing context of the sampled obligation; fixes the terminology (child, Fused/Split, ExecutionShape boundary) in which the selected output condition about preserving the exact floating type, fast-math contract, source location and Ownership lineage is read. Used for terminology only; no extra constraint is derived from it."},{"file_sha256":"bfc1e646e91fe0ba6d7d16e43994100b05c3b8ff79c2e07288e8955c43d9d79d","kind":"documentation_input","lines":"177-186","path":"docs/spec-compiler-part-2-scf.md","roles":["input_construction","applicability"],"text":"FMA normalization is semantic rather than name based. An exact fused LLVM FMA\nbecomes `math.fma`. `llvm.intr.fmuladd` remains unchanged in S0 until one typed\n`ExecutionShape` decision materializes either `Fused` or\n`Split(arith.mulf, arith.addf)` under the exact floating environment and\nfast-math contract. That decision is candidate lineage and may be evaluated as\na performance choice; target code generation cannot choose it implicitly. The\nOwnership generator selects the Spatial region but does not own this decision.\nThe ExecutionShape generator resolves it before Schedule or Dataflow lowering\nmay consume the candidate. After materialization, no `fmuladd` operation may\nremain in a finalizable Sn or be registered as a Canonical Dataflow actor.","why":"States that llvm.intr.fmuladd remains unchanged in S0 until one typed ExecutionShape decision materializes Fused or Split(arith.mulf, arith.addf) under the exact floating environment and fast-math contract, and that the ExecutionShape generator owns that decision. Establishes that the subject stage is loom-materialize-fmuladd with an explicit shape and that the sampled inputs are S0 callables still carrying the intrinsic."},{"file_sha256":"bfc1e646e91fe0ba6d7d16e43994100b05c3b8ff79c2e07288e8955c43d9d79d","kind":"documentation_input","lines":"166-175","path":"docs/spec-compiler-part-2-scf.md","roles":["input_well_formedness"],"text":"The LLVM dialect `passthrough` function attribute is an importer-owned lossless\ncontainer, not a floating-point-environment authority. Mechanical raising uses\none closed classifier owned by the exact-spelling projection. Typed LLVM\nfloating environment attributes, `strictfp`, incompatible exception policy,\nand unknown string attributes block standard spelling. LLVM enum function\nattributes and explicitly classified code-generation-only strings do not.\nClang's default `no-trapping-math=true` is compatible with the ordinary\nnon-constrained floating operation spelling; any other value fails closed.\nOwnership materialization and Dataflow lowering never reinterpret this\nclassification.","why":"The closed classifier for the LLVM passthrough attribute and typed floating-environment attributes: strictfp and unknown string attributes block standard spelling. Justifies the sampled non-representable callables (passthrough strictfp, reciprocal_estimates, no_signed_zeros_fp_math) whose intrinsics must stay explicit, so the postcondition must tolerate unmaterialized slots."},{"file_sha256":"2b0705aba1c16c80e5338d443989a9cdcbac47a60c140bff5b886c617a9f9a8f","kind":"implementation","lines":"1-33,135-165","path":"lib/Frontend/Raising/MaterializeFMulAddPass.cpp","roles":["applicability","input_construction"],"text":"// Materialize the execution shape of `llvm.intr.fmuladd`.\n//\n// `llvm.intr.fmuladd` is not a computation, it is an unmade choice: the target\n// may contract it into one fused multiply-add with a single rounding, or\n// evaluate an ordinary multiply followed by an ordinary add with two. The two\n// results differ, so nothing downstream may pick one implicitly and no shape\n// can be inferred from the intrinsic spelling. Mechanical raising therefore\n// leaves the intrinsic alone, and this pass materializes exactly the one shape\n// its caller selected:\n//\n//   Fused -> math.fma\n//   Split -> arith.mulf then arith.addf\n//\n// The two shapes differ in what they permit, not only in what they spell.\n// Fused carries the complete source fast-math contract onto the one fused\n// operation. Split consumes the source's `contract` permission: the multiply\n// and the add each round on their own, and neither may be contracted back\n// into a single rounding by a later pass or by target code generation.\n//\n// The selected shape is the entire decision this pass makes, so it is a\n// required typed option rather than a defaulted one, in the same shape as the\n// typed Dataflow rewrite catalog.\n//\n// A materialization is legal only when the target operations restate the whole\n// source computation: exact numeric types, the operation's fast-math contract,\n// the default floating-point environment the intrinsic is evaluated in, and\n// the enclosing callable's floating-point environment. `math.fma` and the\n// `arith` floating operations state no environment of their own, so a callable\n// stating one that they cannot restate cannot receive either shape.\n//\n// Representability is intrinsic-local. An intrinsic whose complete semantics\n// the selected standard form cannot restate remains explicit; it does not\n// prevent representable siblings from receiving the selected shape.\n  ::llvm::StringRef getArgument() const final {\n    return \"loom-materialize-fmuladd\";\n  }\n  ::llvm::StringRef getDescription() const final {\n    return \"Materialize one selected execution shape for each exactly \"\n           \"representable llvm.intr.fmuladd in callable regions.\";\n  }\n\n  void getDependentDialects(::mlir::DialectRegistry &registry) const final {\n    registry.insert<::mlir::arith::ArithDialect, ::mlir::LLVM::LLVMDialect,\n                    ::mlir::math::MathDialect>();\n  }\n\n  // The shape is the decision, so there is no default: silently choosing one\n  // would materialize a form the caller never selected.\n  ::mlir::Pass::Option<FMulAddExecutionShape> shape{\n      *this, \"shape\",\n      ::llvm::cl::desc(\"execution shape to materialize for llvm.intr.fmuladd\"),\n      ::llvm::cl::values(\n          clEnumValN(FMulAddExecutionShape::Fused, \"fused\",\n                     \"one math.fma with a single rounding\"),\n          clEnumValN(FMulAddExecutionShape::Split, \"split\",\n                     \"an arith.mulf followed by an arith.addf\"))};\n\n  void runOnOperation() final {\n    if (!shape.hasValue()) {\n      getOperation()->emitError(\n          \"loom-materialize-fmuladd requires an explicit 'shape' option\");\n      return signalPassFailure();\n    }","why":"The stage under test: pass argument string loom-materialize-fmuladd, the required typed 'shape' option with no default (fused -> math.fma, split -> arith.mulf then arith.addf), the fail-closed error when no shape is supplied, and the statement that a materialization keeps the source location and the exact operand and result types. Fixes the subject-command flags and confirms the output population the obligation constrains."},{"file_sha256":"2b0705aba1c16c80e5338d443989a9cdcbac47a60c140bff5b886c617a9f9a8f","kind":"implementation","lines":"59-98","path":"lib/Frontend/Raising/MaterializeFMulAddPass.cpp","roles":["context"],"text":"void materializeOne(::mlir::LLVM::FMulAddOp op, FMulAddExecutionShape shape,\n                    ::mlir::IRRewriter &rewriter) {\n  rewriter.setInsertionPoint(op);\n  ::mlir::Location loc = op.getLoc();\n  ::mlir::Type type = op.getRes().getType();\n  ::mlir::arith::FastMathFlags fastmath =\n      loom::raising::exactFastMathFlags(op.getFastmathFlags());\n  // No materialized operation states a rounding mode. An arith or math\n  // operation that states one is a constrained operation: standard lowering\n  // turns it into `llvm.intr.experimental.constrained.*` under an explicit\n  // rounding and exception mode, and drops the fast-math flags on the way.\n  // llvm.intr.fmuladd is an ordinary non-constrained intrinsic in the default\n  // environment, so both shapes leave the mode absent and lower back to\n  // ordinary LLVM floating operations.\n  if (shape == FMulAddExecutionShape::Fused) {\n    // Fusing is what the shape decided, so the complete source contract,\n    // `contract` included, carries onto the one fused operation.\n    rewriter.replaceOpWithNewOp<::mlir::math::FmaOp>(\n        op, type, op.getA(), op.getB(), op.getC(), fastmath);\n    return;\n  }\n\n  // `contract` is the source's permission to fuse this multiply and add into\n  // one rounding. Selecting Split is the decision that declines it, so the\n  // permission is consumed here rather than restated on the result: a\n  // multiply and an add that still carried it would let any later contraction\n  // -- upstream's own arith-to-math.fma uplift, or a backend -- re-fuse them\n  // and silently undo the shape. Every other source flag is a property of the\n  // computation, not of fusion, and carries onto both operations unchanged.\n  ::mlir::arith::FastMathFlags split = ::mlir::arith::bitEnumClear(\n      fastmath, ::mlir::arith::FastMathFlags::contract);\n\n  auto product =\n      ::mlir::arith::MulFOp::create(rewriter, loc, type, op.getA(), op.getB());\n  product.setFastmath(split);\n  auto sum = ::mlir::arith::AddFOp::create(rewriter, loc, type,\n                                           product.getResult(), op.getC());\n  sum.setFastmath(split);\n  rewriter.replaceOp(op, sum);\n}","why":"Acceptance behaviour of one materialization: the Fused child carries the complete source fast-math contract, while the Split children clear the contract permission. Evidence for the stage-attribution note in AUTHORING-RESULT.md and for selecting shape=fused, whose child is the one the documented preservation wording holds of literally."},{"file_sha256":"fc8794a0235430f2ab7b87b0fb63e4991acfa052ab630501b484fce956154a56","kind":"verifier","lines":"35-52,123-161","path":"lib/Frontend/Raising/ExactStandardSpelling.h","roles":["input_well_formedness","applicability"],"text":"inline bool isExactNumericType(::mlir::Type type) {\n  if (auto vectorType = ::mlir::dyn_cast<::mlir::VectorType>(type)) {\n    if (vectorType.isScalable())\n      return false;\n    type = vectorType.getElementType();\n  }\n  if (auto integerType = ::mlir::dyn_cast<::mlir::IntegerType>(type))\n    return integerType.isSignless() && integerType.getWidth() > 0;\n  return ::mlir::isa<::mlir::IndexType, ::mlir::FloatType>(type);\n}\n\ninline bool allExactNumericTypes(::mlir::ValueRange values) {\n  for (::mlir::Value value : values) {\n    if (!isExactNumericType(value.getType()))\n      return false;\n  }\n  return true;\n}\ninline bool statesFloatingPolicy(::mlir::LLVM::LLVMFuncOp funcOp) {\n  if (auto env = funcOp.getDenormalFpenvAttr())\n    if (!statesDefaultDenormalEnvironment(env))\n      return true;\n  if (auto noSignedZeros = funcOp.getNoSignedZerosFpMathAttr())\n    if (noSignedZeros.getValue())\n      return true;\n  if (auto contraction = funcOp.getFpContractAttr())\n    if (contraction.getValue() != \"off\")\n      return true;\n  if (funcOp.getReciprocalEstimatesAttr())\n    return true;\n  if (auto passthrough = funcOp.getPassthroughAttr())\n    for (::mlir::Attribute entry : passthrough)\n      if (passthroughEntryStatesFloatingPolicy(entry))\n        return true;\n  return false;\n}\n\n// True when the enclosing callable states a floating-point environment the\n// standard operation cannot restate.\ninline bool enclosingFloatingPolicyBlocksRewrite(::mlir::Operation *op) {\n  auto funcOp = ::mlir::dyn_cast_or_null<::mlir::LLVM::LLVMFuncOp>(\n      getNearestCallableOp(op));\n  return funcOp && statesFloatingPolicy(funcOp);\n}\n\n// True when every operand and the single result of `op` have an exact standard\n// counterpart and, for a computation that reads or produces a floating value,\n// the enclosing callable states no environment the standard operation cannot\n// restate. An integer computation is independent of that environment and is\n// never blocked by it.\ninline bool restatesExactly(::mlir::Operation *op, bool floating) {\n  if (!allExactNumericTypes(op->getOperands()))\n    return false;\n  if (!isExactNumericType(op->getResult(0).getType()))\n    return false;\n  return !floating || !enclosingFloatingPolicyBlocksRewrite(op);\n}","why":"Acceptance implementation of 'exactly representable': exact numeric types (signless integers, index, floats, fixed-shape vectors) and an enclosing llvm.func that states no floating policy (denormal env, no_signed_zeros_fp_math, fp_contract, reciprocal_estimates, passthrough). Determines which sampled types (f16/f32/f64/vector<4xf32>) are materialized and which sampled callables keep their intrinsic."},{"file_sha256":"fc8794a0235430f2ab7b87b0fb63e4991acfa052ab630501b484fce956154a56","kind":"language_definition","lines":"163-189","path":"lib/Frontend/Raising/ExactStandardSpelling.h","roles":["context"],"text":"// arith counterpart of LLVM's fast-math flags. Both enums name the same\n// seven facts but assign them different bit positions, so each flag is\n// mapped by name instead of being reinterpreted.\ninline ::mlir::arith::FastMathFlags\nexactFastMathFlags(::mlir::LLVM::FastmathFlags flags) {\n  const std::pair<::mlir::LLVM::FastmathFlags, ::mlir::arith::FastMathFlags>\n      equivalents[] = {\n          {::mlir::LLVM::FastmathFlags::nnan,\n           ::mlir::arith::FastMathFlags::nnan},\n          {::mlir::LLVM::FastmathFlags::ninf,\n           ::mlir::arith::FastMathFlags::ninf},\n          {::mlir::LLVM::FastmathFlags::nsz, ::mlir::arith::FastMathFlags::nsz},\n          {::mlir::LLVM::FastmathFlags::arcp,\n           ::mlir::arith::FastMathFlags::arcp},\n          {::mlir::LLVM::FastmathFlags::contract,\n           ::mlir::arith::FastMathFlags::contract},\n          {::mlir::LLVM::FastmathFlags::afn, ::mlir::arith::FastMathFlags::afn},\n          {::mlir::LLVM::FastmathFlags::reassoc,\n           ::mlir::arith::FastMathFlags::reassoc}};\n\n  ::mlir::arith::FastMathFlags result{};\n  for (auto [llvmFlag, arithFlag] : equivalents) {\n    if (::mlir::LLVM::bitEnumContainsAll(flags, llvmFlag))\n      result = result | arithFlag;\n  }\n  return result;\n}","why":"The name-by-name equivalence between LLVM's FastmathFlags and arith's FastMathFlags (nnan, ninf, nsz, arcp, contract, afn, reassoc are the same seven facts in two enums). Fixes the two dialect spellings of one fast-math contract that the postcondition's spelling correspondence table relates; it adds no behavioural requirement."},{"file_sha256":"d1315fabeb736f07fdd93eca093e20d05a201967b181a40cb02f37048ba2c79a","kind":"implementation","lines":"29-31,55-95","path":"lib/Frontend/Raising/CallableRegions.h","roles":["input_construction","input_well_formedness"],"text":"inline bool isCallableOp(::mlir::Operation *op) {\n  return ::mlir::isa<::mlir::LLVM::LLVMFuncOp, ::mlir::func::FuncOp>(op);\n}\ninline ::mlir::LogicalResult forEachCallableRegion(\n    ::mlir::Operation *root,\n    ::llvm::function_ref<::mlir::LogicalResult(::mlir::Region &)> transform) {\n  ::mlir::WalkResult walked =\n      root->walk<::mlir::WalkOrder::PostOrder>([&](::mlir::Operation *op) {\n        if (!isCallableOp(op))\n          return ::mlir::WalkResult::advance();\n        for (::mlir::Region &region : op->getRegions()) {\n          if (region.empty())\n            continue;\n          if (failed(transform(region)))\n            return ::mlir::WalkResult::interrupt();\n        }\n        return ::mlir::WalkResult::advance();\n      });\n  return walked.wasInterrupted() ? ::mlir::failure() : ::mlir::success();\n}\n\n// Offer `visit` to every operation `region` owns, recursing into nested\n// regions that belong to the same callable -- scf.for, scf.if, a graph\n// region -- but stopping at any nested callable, whose own body this region\n// must not claim to own.\n//\n// This is the operation-level half of callable ownership: a callable processes\n// exactly the operations its nearest enclosing callable owns, and a nested\n// callable's body is left to that callable's own region-level walk. Crossing\n// into a nested callable here would visit its operations twice -- once\n// descended into from the enclosing region and once from the callable's own\n// walk -- so the nested callable is pruned instead. Pruning happens in\n// pre-order: in a post-order walk a callable's body is visited before the\n// callable itself, so the skip would arrive one descent too late.\ninline ::mlir::WalkResult forEachOwnedOperation(\n    ::mlir::Region &region,\n    ::llvm::function_ref<::mlir::WalkResult(::mlir::Operation *)> visit) {\n  return region.walk<::mlir::WalkOrder::PreOrder>(\n      [&](::mlir::Operation *op) -> ::mlir::WalkResult {\n        if (isCallableOp(op))\n          return ::mlir::WalkResult::skip();\n        return visit(op);\n      });\n}","why":"Callable kinds of an S0 program (llvm.func, func.func) and the ownership walk that prunes nested callables, so each operation is owned by exactly one callable. Fixes the two callable spellings the grammar emits and the innermost-callable ownership scoping used by the postcondition's owned_shape_slots definition."},{"file_sha256":"6f55dfe3ca2a9edcd0d955b965b5011a8010478cf28db89485df1fdfb2750c9c","kind":"test","lines":"1-16","path":"test/raise/fmuladd-materialization.mlir","roles":["applicability"],"text":"// RUN: split-file %s %t\n// RUN: not loom-raise-opt --loom-materialize-fmuladd %t/choice.mlir 2>&1 | FileCheck %s --check-prefix=UNSELECTED\n// RUN: loom-raise-opt --loom-materialize-fmuladd=shape=fused %t/choice.mlir | FileCheck %s --check-prefix=FUSED\n// RUN: loom-raise-opt --loom-materialize-fmuladd=shape=split %t/choice.mlir | FileCheck %s --check-prefix=SPLIT\n// RUN: loom-raise-opt --loom-materialize-fmuladd=shape=fused %t/choice.mlir | mlir-opt --convert-math-to-llvm --convert-arith-to-llvm | FileCheck %s --check-prefix=FUSED-LLVM --implicit-check-not=constrained\n// RUN: loom-raise-opt --loom-materialize-fmuladd=shape=split %t/choice.mlir | mlir-opt --convert-math-to-llvm --convert-arith-to-llvm | FileCheck %s --check-prefix=SPLIT-LLVM --implicit-check-not=constrained\n// RUN: loom-raise-opt --loom-materialize-fmuladd=shape=split %t/choice.mlir | mlir-opt --math-uplift-to-fma | FileCheck %s --check-prefix=SPLIT-KEPT --implicit-check-not=math.fma\n// RUN: loom-raise-opt --loom-materialize-fmuladd=shape=fused %t/unrepresentable.mlir | FileCheck %s --check-prefix=SCOPED\n// RUN: loom-raise-opt --loom-materialize-fmuladd=shape=fused %t/nested.mlir | FileCheck %s --check-prefix=NESTED --implicit-check-not=llvm.intr.fmuladd\n// RUN: loom-raise-opt --loom-lower-for-to-graph --mlir-disable-threading %t/selected-fused.mlir | FileCheck %s --check-prefix=SELECTED-FUSED --implicit-check-not=loom.spatial_region\n\n// `llvm.intr.fmuladd` states a choice, not a computation: the target may fuse\n// it into one rounding or evaluate a separate multiply and add. Materializing\n// that choice is a typed decision with no default, so the shape is required\n// and is never inferred from the intrinsic spelling.\n// UNSELECTED: loom-materialize-fmuladd requires an explicit 'shape' option","why":"Non-normative evidence for the exact invocation of this stage: '--loom-materialize-fmuladd=shape=fused' / '=shape=split' and the diagnostic produced when the shape option is omitted. Basis for the revised subject-command args and their rationale."},{"file_sha256":"6f55dfe3ca2a9edcd0d955b965b5011a8010478cf28db89485df1fdfb2750c9c","kind":"example","lines":"91-126","path":"test/raise/fmuladd-materialization.mlir","roles":["input_construction"],"text":"//--- choice.mlir\nllvm.func @chosen(%x: f32, %y: f32, %z: f32) -> f32 {\n  %r = llvm.intr.fmuladd(%x, %y, %z)\n      {fastmathFlags = #llvm.fastmath<nnan, contract>} : (f32, f32, f32) -> f32\n  llvm.return %r : f32\n}\n\nllvm.func @vector_chosen(%x: vector<4xf32>, %y: vector<4xf32>,\n                         %z: vector<4xf32>) -> vector<4xf32> {\n  %r = llvm.intr.fmuladd(%x, %y, %z)\n      : (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32>\n  llvm.return %r : vector<4xf32>\n}\n\n//--- unrepresentable.mlir\nllvm.func @representable(%x: f32, %y: f32, %z: f32) -> f32 {\n  %r = llvm.intr.fmuladd(%x, %y, %z) : (f32, f32, f32) -> f32\n  llvm.return %r : f32\n}\n\nllvm.func @estimated(%x: f32, %y: f32, %z: f32) -> f32\n    attributes {reciprocal_estimates = \"all\"} {\n  %r = llvm.intr.fmuladd(%x, %y, %z) : (f32, f32, f32) -> f32\n  llvm.return %r : f32\n}\n\n//--- nested.mlir\nfunc.func @native_owner(%a: f32, %b: f32, %c: f32) -> f32 {\n  builtin.module {\n    llvm.func @inner(%x: f32, %y: f32, %z: f32) -> f32 {\n      %r = llvm.intr.fmuladd(%x, %y, %z) : (f32, f32, f32) -> f32\n      llvm.return %r : f32\n    }\n  }\n  return %a : f32\n}","why":"Accepted input spellings reused as the skeleton of the grammar: llvm.func with scalar and vector fmuladd and fastmathFlags = #llvm.fastmath<...>, a callable whose reciprocal_estimates policy blocks materialization, and a func.func owning a nested builtin.module with an llvm.func. Names, types and cardinalities are treated as one accepted spelling only."},{"file_sha256":"6f55dfe3ca2a9edcd0d955b965b5011a8010478cf28db89485df1fdfb2750c9c","kind":"test","lines":"18-40","path":"test/raise/fmuladd-materialization.mlir","roles":["context"],"text":"// Fusing is what the fused shape decided, so the exact operand and result\n// types and the complete imported fast-math contract -- `contract` included --\n// all carry onto the one `math.fma`.\n// FUSED-LABEL: llvm.func @chosen\n// FUSED: math.fma %arg0, %arg1, %arg2 fastmath<nnan,contract> : f32\n// FUSED-NOT: llvm.intr.fmuladd\n// FUSED-LABEL: llvm.func @vector_chosen\n// FUSED: math.fma %arg0, %arg1, %arg2 : vector<4xf32>\n// FUSED-NOT: llvm.intr.fmuladd\n\n// The split shape is an ordinary multiply then an ordinary add, each rounding\n// on its own. `contract` is the source's permission to fuse them back into one\n// rounding, so selecting Split consumes it: neither operation restates it.\n// Every other imported flag describes the computation rather than the fusion\n// and carries onto both operations unchanged.\n// SPLIT-LABEL: llvm.func @chosen\n// SPLIT: %[[PROD:.*]] = arith.mulf %arg0, %arg1 fastmath<nnan> : f32\n// SPLIT: arith.addf %[[PROD]], %arg2 fastmath<nnan> : f32\n// SPLIT-NOT: llvm.intr.fmuladd\n// SPLIT-LABEL: llvm.func @vector_chosen\n// SPLIT: %[[VPROD:.*]] = arith.mulf %arg0, %arg1 : vector<4xf32>\n// SPLIT: arith.addf %[[VPROD]], %arg2 : vector<4xf32>\n// SPLIT-NOT: llvm.intr.fmuladd","why":"Non-normative evidence of the fast-math spellings on both sides of the rewrite (#llvm.fastmath<nnan, contract> on the intrinsic, fastmath<nnan,contract> on math.fma, contract absent on the split children). Used only to fix the two dialect spellings of one contract that the postcondition's spelling correspondence table relates."}],"primary_bundle_sha256":"33099887f46470c09e8577705091e3d07a426f909222b7bdfbe0610d7ff970ed","project":"PolyArch/loom","revision":"48615bc5925ef4b9db8b4550b5d4322933cf4b7b","schema":"spectriad.authoring-context/v1","selection_sha256":"e54e306ef453403889124a88878b90dde2bb0d1a050089fc65afbe3b1f1d1c37"}