update blocks

Author: 0xGeorgii

llvm/include/llvm/IR/IntrinsicsWebAssembly.td

@@ -135,28 +135,28 @@ def int_wasm_uzumaki_i64 :
 // transforms into proper blocks
 
 def int_wasm_forall_start :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 def int_wasm_forall_end :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 def int_wasm_exists_start :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 def int_wasm_exists_end :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 def int_wasm_assume_start :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 def int_wasm_assume_end :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 def int_wasm_unique_start :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 def int_wasm_unique_end :
-  DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+  DefaultAttrsIntrinsic<[], [], [IntrHasSideEffects]>;
 
 //===----------------------------------------------------------------------===//
 // Exception handling intrinsics

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

@@ -3428,6 +3428,28 @@ void SelectionDAGBuilder::visitInvoke(const InvokeInst &I) {
       DAG.setRoot(DAG.getNode(ISD::INTRINSIC_VOID, getCurSDLoc(), VTs, Ops));
       break;
     }
+    // Inference block intrinsics: handle them like wasm_throw/wasm_rethrow
+    // to prevent crashes in visitTargetIntrinsic
+    case Intrinsic::wasm_forall_start:
+    case Intrinsic::wasm_forall_end:
+    case Intrinsic::wasm_exists_start:
+    case Intrinsic::wasm_exists_end:
+    case Intrinsic::wasm_assume_start:
+    case Intrinsic::wasm_assume_end:
+    case Intrinsic::wasm_unique_start:
+    case Intrinsic::wasm_unique_end: {
+      const TargetLowering &TLI = DAG.getTargetLoweringInfo();
+      unsigned IntrID = cast<IntrinsicInst>(I).getIntrinsicID();
+      llvm::errs() << "DEBUG: Special handling for inference block intrinsic " << IntrID << "\n";
+      std::array<SDValue, 2> Ops = {
+          getControlRoot(), // inchain for the terminator node
+          DAG.getTargetConstant(IntrID, getCurSDLoc(),
+                                TLI.getPointerTy(DAG.getDataLayout()))};
+      SDVTList VTs = DAG.getVTList(ArrayRef<EVT>({MVT::Other})); // outchain
+      llvm::errs() << "DEBUG: Creating INTRINSIC_VOID node for instruction selection\n";
+      DAG.setRoot(DAG.getNode(ISD::INTRINSIC_VOID, getCurSDLoc(), VTs, Ops));
+      break;
+    }
     }
   } else if (I.hasDeoptState()) {
     // Currently we do not lower any intrinsic calls with deopt operand bundles.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

@@ -656,26 +656,26 @@ void WebAssemblyAsmPrinter::emitInstruction(const MachineInstr *MI) {
     break;
   }
   // Inference block instructions
-  case WebAssembly::BLOCK_FORALL: {
+  case WebAssembly::INFERENCE_FORALL: {
     OutStreamer->emitIntValue(0xFC, 1);
     OutStreamer->emitIntValue(0x3A, 1);
     // Emit block type (0x40 for void)
     OutStreamer->emitIntValue(0x40, 1);
     break;
   }
-  case WebAssembly::BLOCK_EXISTS: {
+  case WebAssembly::INFERENCE_EXISTS: {
     OutStreamer->emitIntValue(0xFC, 1);
     OutStreamer->emitIntValue(0x3B, 1);
     OutStreamer->emitIntValue(0x40, 1);
     break;
   }
-  case WebAssembly::BLOCK_ASSUME: {
+  case WebAssembly::INFERENCE_ASSUME: {
     OutStreamer->emitIntValue(0xFC, 1);
     OutStreamer->emitIntValue(0x3C, 1);
     OutStreamer->emitIntValue(0x40, 1);
     break;
   }
-  case WebAssembly::BLOCK_UNIQUE: {
+  case WebAssembly::INFERENCE_UNIQUE: {
     OutStreamer->emitIntValue(0xFC, 1);
     OutStreamer->emitIntValue(0x3D, 1);
     OutStreamer->emitIntValue(0x40, 1);

llvm/lib/Target/WebAssembly/WebAssemblyISD.def

@@ -55,6 +55,10 @@ HANDLE_NODETYPE(BLOCK_FORALL)
 HANDLE_NODETYPE(BLOCK_EXISTS)
 HANDLE_NODETYPE(BLOCK_ASSUME)
 HANDLE_NODETYPE(BLOCK_UNIQUE)
+HANDLE_NODETYPE(BLOCK_FORALL_END)
+HANDLE_NODETYPE(BLOCK_EXISTS_END)
+HANDLE_NODETYPE(BLOCK_ASSUME_END)
+HANDLE_NODETYPE(BLOCK_UNIQUE_END)
 
 // Memory intrinsics
 HANDLE_NODETYPE(GLOBAL_GET)

llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp

@@ -232,6 +232,7 @@ void WebAssemblyDAGToDAGISel::Select(SDNode *Node) {
 
   case ISD::INTRINSIC_VOID: {
     unsigned IntNo = Node->getConstantOperandVal(1);
+    llvm::errs() << "DEBUG: INTRINSIC_VOID instruction selection for intrinsic " << IntNo << "\n";
     switch (IntNo) {
     case Intrinsic::wasm_throw: {
       int Tag = Node->getConstantOperandVal(2);
@@ -260,10 +261,159 @@ void WebAssemblyDAGToDAGISel::Select(SDNode *Node) {
       ReplaceNode(Node, Rethrow);
       return;
     }
+    
+    // Inference block intrinsics
+    case Intrinsic::wasm_forall_start: {
+      llvm::errs() << "DEBUG: Custom instruction selection for wasm_forall_start\n";
+      MachineSDNode *ForallStart = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_FORALL, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, ForallStart);
+      return;
+    }
+    case Intrinsic::wasm_exists_start: {
+      MachineSDNode *ExistsStart = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_EXISTS, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, ExistsStart);
+      return;
+    }
+    case Intrinsic::wasm_assume_start: {
+      MachineSDNode *AssumeStart = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_ASSUME, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, AssumeStart);
+      return;
+    }
+    case Intrinsic::wasm_unique_start: {
+      MachineSDNode *UniqueStart = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_UNIQUE, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, UniqueStart);
+      return;
+    }
+    case Intrinsic::wasm_forall_end: {
+      MachineSDNode *ForallEnd = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_FORALL_END, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, ForallEnd);
+      return;
+    }
+    case Intrinsic::wasm_exists_end: {
+      MachineSDNode *ExistsEnd = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_EXISTS_END, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, ExistsEnd);
+      return;
+    }
+    case Intrinsic::wasm_assume_end: {
+      MachineSDNode *AssumeEnd = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_ASSUME_END, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, AssumeEnd);
+      return;
+    }
+    case Intrinsic::wasm_unique_end: {
+      MachineSDNode *UniqueEnd = CurDAG->getMachineNode(
+          WebAssembly::INFERENCE_UNIQUE_END, DL,
+          MVT::Other, // outchain type
+          Node->getOperand(0) // inchain
+      );
+      ReplaceNode(Node, UniqueEnd);
+      return;
+    }
     }
     break;
   }
 
+
+  // Inference block instructions
+  case WebAssemblyISD::BLOCK_FORALL: {
+    MachineSDNode *ForallStart = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_FORALL, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, ForallStart);
+    return;
+  }
+  case WebAssemblyISD::BLOCK_EXISTS: {
+    MachineSDNode *ExistsStart = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_EXISTS, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, ExistsStart);
+    return;
+  }
+  case WebAssemblyISD::BLOCK_ASSUME: {
+    MachineSDNode *AssumeStart = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_ASSUME, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, AssumeStart);
+    return;
+  }
+  case WebAssemblyISD::BLOCK_UNIQUE: {
+    MachineSDNode *UniqueStart = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_UNIQUE, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, UniqueStart);
+    return;
+  }
+  case WebAssemblyISD::BLOCK_FORALL_END: {
+    MachineSDNode *ForallEnd = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_FORALL_END, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, ForallEnd);
+    return;
+  }
+  case WebAssemblyISD::BLOCK_EXISTS_END: {
+    MachineSDNode *ExistsEnd = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_EXISTS_END, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, ExistsEnd);
+    return;
+  }
+  case WebAssemblyISD::BLOCK_ASSUME_END: {
+    MachineSDNode *AssumeEnd = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_ASSUME_END, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, AssumeEnd);
+    return;
+  }
+  case WebAssemblyISD::BLOCK_UNIQUE_END: {
+    MachineSDNode *UniqueEnd = CurDAG->getMachineNode(
+        WebAssembly::INFERENCE_UNIQUE_END, DL,
+        MVT::Other, // outchain type
+        Node->getOperand(0) // inchain
+    );
+    ReplaceNode(Node, UniqueEnd);
+    return;
+  }
   case WebAssemblyISD::CALL:
   case WebAssemblyISD::RET_CALL: {
     // CALL has both variable operands and variable results, but ISel only

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

@@ -2216,23 +2216,23 @@ SDValue WebAssemblyTargetLowering::LowerIntrinsic(SDValue Op,
   case Intrinsic::wasm_uzumaki_i64:
     return DAG.getNode(WebAssemblyISD::UZUMAKI_I64, DL, MVT::i64);
 
-  // Inference block start markers
+  // Inference block intrinsics - lower to WebAssemblyISD nodes
   case Intrinsic::wasm_forall_start:
     return DAG.getNode(WebAssemblyISD::BLOCK_FORALL, DL, MVT::Other, Op.getOperand(0));
+  case Intrinsic::wasm_forall_end:
+    return DAG.getNode(WebAssemblyISD::BLOCK_FORALL_END, DL, MVT::Other, Op.getOperand(0));
   case Intrinsic::wasm_exists_start:
     return DAG.getNode(WebAssemblyISD::BLOCK_EXISTS, DL, MVT::Other, Op.getOperand(0));
+  case Intrinsic::wasm_exists_end:
+    return DAG.getNode(WebAssemblyISD::BLOCK_EXISTS_END, DL, MVT::Other, Op.getOperand(0));
   case Intrinsic::wasm_assume_start:
     return DAG.getNode(WebAssemblyISD::BLOCK_ASSUME, DL, MVT::Other, Op.getOperand(0));
+  case Intrinsic::wasm_assume_end:
+    return DAG.getNode(WebAssemblyISD::BLOCK_ASSUME_END, DL, MVT::Other, Op.getOperand(0));
   case Intrinsic::wasm_unique_start:
     return DAG.getNode(WebAssemblyISD::BLOCK_UNIQUE, DL, MVT::Other, Op.getOperand(0));
-
-  // Block end markers are lowered to standard WASM 'end' instruction
-  case Intrinsic::wasm_forall_end:
-  case Intrinsic::wasm_exists_end:
-  case Intrinsic::wasm_assume_end:
   case Intrinsic::wasm_unique_end:
-    // These are handled as part of block scope management
-    return Op.getOperand(0);  // Just pass through the chain
+    return DAG.getNode(WebAssemblyISD::BLOCK_UNIQUE_END, DL, MVT::Other, Op.getOperand(0));
 
   case Intrinsic::wasm_lsda: {
     auto PtrVT = getPointerTy(MF.getDataLayout());

llvm/lib/Target/WebAssembly/WebAssemblyInstrControl.td

@@ -237,3 +237,22 @@ defm BLOCK_UNIQUE : NRI<(outs), (ins Signature:$sig),
                          [],
                          "block.unique\t$sig", 0x00>;
 }
+
+// Inference block instructions: side-effect operations like exception handling
+let hasCtrlDep = 1, hasSideEffects = 1, Uses = [VALUE_STACK], Defs = [VALUE_STACK] in {
+defm INFERENCE_FORALL : NRI<(outs), (ins), [], "forall", 0x00>;
+defm INFERENCE_EXISTS : NRI<(outs), (ins), [], "exists", 0x00>;
+defm INFERENCE_ASSUME : NRI<(outs), (ins), [], "assume", 0x00>;
+defm INFERENCE_UNIQUE : NRI<(outs), (ins), [], "unique", 0x00>;
+
+// End markers for inference blocks (generate regular 'end' instruction)  
+defm INFERENCE_FORALL_END : NRI<(outs), (ins), [], "end", 0x0b>;
+defm INFERENCE_EXISTS_END : NRI<(outs), (ins), [], "end", 0x0b>;
+defm INFERENCE_ASSUME_END : NRI<(outs), (ins), [], "end", 0x0b>;
+defm INFERENCE_UNIQUE_END : NRI<(outs), (ins), [], "end", 0x0b>;
+}
+
+// Patterns to connect chain-based SDNodes to inference block instructions  
+// Note: These patterns expect chain inputs but our instructions have no operands
+// This approach may need a different strategy
+

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

@@ -115,6 +115,7 @@ def SDT_WebAssemblyGlobalGet  : SDTypeProfile<1, 1, [SDTCisPtrTy<1>]>;
 def SDT_WebAssemblyGlobalSet  : SDTypeProfile<0, 2, [SDTCisPtrTy<1>]>;
 def SDT_WebAssemblyUzumakiI32 : SDTypeProfile<1, 0, [SDTCisVT<0, i32>]>;
 def SDT_WebAssemblyUzumakiI64 : SDTypeProfile<1, 0, [SDTCisVT<0, i64>]>;
+def SDT_WebAssemblyChainVoid  : SDTypeProfile<1, 1, []>;
 
 //===----------------------------------------------------------------------===//
 // WebAssembly-specific DAG Nodes.
@@ -151,13 +152,23 @@ def WebAssemblyuzumaki_i64 : SDNode<"WebAssemblyISD::UZUMAKI_I64",
 
 // Inference block SDNodes
 def WebAssemblyforall_start : SDNode<"WebAssemblyISD::BLOCK_FORALL",
-                  SDTNone, [SDNPHasChain]>;
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
 def WebAssemblyexists_start : SDNode<"WebAssemblyISD::BLOCK_EXISTS",
-                  SDTNone, [SDNPHasChain]>;
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
 def WebAssemblyassume_start : SDNode<"WebAssemblyISD::BLOCK_ASSUME",
-                  SDTNone, [SDNPHasChain]>;
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
 def WebAssemblyunique_start : SDNode<"WebAssemblyISD::BLOCK_UNIQUE",
-                  SDTNone, [SDNPHasChain]>;
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
+
+// Inference block end markers (use regular 'end' instruction)
+def WebAssemblyforall_end : SDNode<"WebAssemblyISD::BLOCK_FORALL_END",
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
+def WebAssemblyexists_end : SDNode<"WebAssemblyISD::BLOCK_EXISTS_END",
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
+def WebAssemblyassume_end : SDNode<"WebAssemblyISD::BLOCK_ASSUME_END",
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
+def WebAssemblyunique_end : SDNode<"WebAssemblyISD::BLOCK_UNIQUE_END",
+                  SDT_WebAssemblyChainVoid, [SDNPHasChain]>;
 
 def WebAssemblylocal_get :
     SDNode<"WebAssemblyISD::LOCAL_GET", SDT_WebAssemblyLocalGet,