[mlir][LLVM] Support locations in loop annotation

[Dinistro]

Summary

This commit introduces support for locations as part of the loop
annotation attribute. These locations indicate the start and the end of
the loop.

[Dinistro]

fix tests

[gysit]

LGTM modulo nit comments.

mlir/lib/Target/LLVMIR/LoopAnnotationImporter.cpp

26

nit: for converting member functions or for the conversion of member functions?

413

Is FailureOr here needed? It seems like we use nullptr to signal failure?

424

I assume LLVM models same start and end location by adding only one location? Should we just set start and end location to the same value in that case?

[Dinistro]

address reviewer comments

mlir/lib/Target/LLVMIR/LoopAnnotationImporter.cpp

413

For the start loc, this is indeed not required. I added it to be compatible with the templated attribute construction further down.

424

From the LangRef (https://llvm.org/docs/LangRef.html#llvm-loop):

Prior to the property nodes, one or two DILocation (debug location) nodes can be present in the list. The first, if present, identifies the source-code location where the loop begins. The second, if present, identifies the source-code location where the loop ends.

So the second one really indicates the end.
I added an error when there are more than two locations, though.

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td

let parameters = (ins
     OptionalParameter<"LoopUnrollAndJamAttr">:$unrollAndJam,
     OptionalParameter<"LoopLICMAttr">:$licm,
     OptionalParameter<"LoopDistributeAttr">:$distribute,
     OptionalParameter<"LoopPipelineAttr">:$pipeline,
     OptionalParameter<"LoopPeeledAttr">:$peeled,
     OptionalParameter<"LoopUnswitchAttr">:$unswitch,
     OptionalParameter<"BoolAttr">:$mustProgress,
     OptionalParameter<"BoolAttr">:$isVectorized,
-    OptionalArrayRefParameter<"SymbolRefAttr">:$parallelAccesses
+    OptionalArrayRefParameter<"SymbolRefAttr">:$parallelAccesses,
+    OptionalParameter<"FusedLoc">:$startLoc,
+    OptionalParameter<"FusedLoc">:$endLoc
   );
 
   let assemblyFormat = "`<` struct(params) `>`";
 }
 
 //===----------------------------------------------------------------------===//
 // DebugInfo Attributes
 //===----------------------------------------------------------------------===//

mlir/lib/Target/LLVMIR/LoopAnnotationImporter.h

 namespace LLVM {
 namespace detail {
 
 /// A helper class that converts llvm.loop metadata nodes into corresponding
 /// LoopAnnotationAttrs and llvm.access.group nodes into
 /// AccessGroupMetadataOps.
 class LoopAnnotationImporter {
 public:
-  explicit LoopAnnotationImporter(OpBuilder &builder) : builder(builder) {}
+  LoopAnnotationImporter(ModuleImport &moduleImport, OpBuilder &builder)
+      : moduleImport(moduleImport), builder(builder) {}
   LoopAnnotationAttr translateLoopAnnotation(const llvm::MDNode *node,
                                              Location loc);
 
   /// Converts all LLVM access groups starting from node to MLIR access group
   /// operations mested in the region of metadataOp. It stores a mapping from
   /// every nested access group nod to the symbol pointing to the translated
   /// operation. Returns success if all conversions succeed and failure
   /// otherwise.
   LogicalResult translateAccessGroup(const llvm::MDNode *node, Location loc,
                                      MetadataOp metadataOp);
 
   /// Returns the symbol references pointing to the access group operations that
   /// map to the access group nodes starting from the access group metadata
   /// node. Returns failure, if any of the symbol references cannot be found.
   FailureOr<SmallVector<SymbolRefAttr>>
   lookupAccessGroupAttrs(const llvm::MDNode *node) const;
 
+  /// The ModuleImport owning this instance.
+  ModuleImport &moduleImport;
+
 private:
   /// Returns the LLVM metadata corresponding to a llvm loop metadata attribute.
   LoopAnnotationAttr lookupLoopMetadata(const llvm::MDNode *node) const {
     return loopMetadataMapping.lookup(node);
   }
 
   void mapLoopMetadata(const llvm::MDNode *metadata, LoopAnnotationAttr attr) {
     auto result = loopMetadataMapping.try_emplace(metadata, attr);

mlir/lib/Target/LLVMIR/LoopAnnotationImporter.cpp

 struct LoopMetadataConversion {
   LoopMetadataConversion(const llvm::MDNode *node, Location loc,
                          LoopAnnotationImporter &loopAnnotationImporter)
       : node(node), loc(loc), loopAnnotationImporter(loopAnnotationImporter),
         ctx(loc->getContext()){};
   /// Converts this structs loop metadata node into a LoopAnnotationAttr.
   LoopAnnotationAttr convert();
 
-  LogicalResult initPropertyMap();
+  /// Initializes the shared state for the conversion member functions.
+  LogicalResult initState();
 
   /// Helper function to get and erase a property.
   const llvm::MDNode *lookupAndEraseProperty(StringRef name);
 
   /// Helper functions to lookup and convert MDNodes into a specifc attribute
   /// kind. These functions return null-attributes if there is no node with the
   /// specified name, or failure, if the node is ill-formatted.
   FailureOr<BoolAttr> lookupUnitNode(StringRef name);
struct LoopMetadataConversion {
   FailureOr<LoopUnrollAttr> convertUnrollAttr();
   FailureOr<LoopUnrollAndJamAttr> convertUnrollAndJamAttr();
   FailureOr<LoopLICMAttr> convertLICMAttr();
   FailureOr<LoopDistributeAttr> convertDistributeAttr();
   FailureOr<LoopPipelineAttr> convertPipelineAttr();
   FailureOr<LoopPeeledAttr> convertPeeledAttr();
   FailureOr<LoopUnswitchAttr> convertUnswitchAttr();
   FailureOr<SmallVector<SymbolRefAttr>> convertParallelAccesses();
+  FailureOr<FusedLoc> convertStartLoc();
+  FailureOr<FusedLoc> convertEndLoc();
 
+  llvm::SmallVector<llvm::DILocation *, 2> locations;
   llvm::StringMap<const llvm::MDNode *> propertyMap;
   const llvm::MDNode *node;
   Location loc;
   LoopAnnotationImporter &loopAnnotationImporter;
   MLIRContext *ctx;
 };
 } // namespace
 
-LogicalResult LoopMetadataConversion::initPropertyMap() {
+LogicalResult LoopMetadataConversion::initState() {
   // Check if it's a valid node.
   if (node->getNumOperands() == 0 ||
       dyn_cast<llvm::MDNode>(node->getOperand(0)) != node)
     return emitWarning(loc) << "invalid loop node";
 
   for (const llvm::MDOperand &operand : llvm::drop_begin(node->operands())) {
-    // Skip over DILocations.
-    if (isa<llvm::DILocation>(operand))
+    if (auto *diLoc = dyn_cast<llvm::DILocation>(operand)) {
+      locations.push_back(diLoc);
       continue;
+    }
 
     auto *property = dyn_cast<llvm::MDNode>(operand);
     if (!property)
       return emitWarning(loc) << "expected all loop properties to be either "
                                  "debug locations or metadata nodes";
 
     if (property->getNumOperands() == 0)
       return emitWarning(loc) << "cannot import empty loop property";
if (failed(accessGroups)) {
       emitWarning(loc) << "could not lookup access group";
       continue;
     }
     llvm::append_range(refs, *accessGroups);
   }
   return refs;
 }
 
+FailureOr<FusedLoc> LoopMetadataConversion::convertStartLoc() {
+  if (locations.empty())
+    return FusedLoc();
+  return dyn_cast<FusedLoc>(
+      loopAnnotationImporter.moduleImport.translateLoc(locations[0]));
+}
+
+FailureOr<FusedLoc> LoopMetadataConversion::convertEndLoc() {
+  if (locations.size() < 2)
+    return FusedLoc();
+  return dyn_cast<FusedLoc>(
+      loopAnnotationImporter.moduleImport.translateLoc(locations[1]));
+}
+
 LoopAnnotationAttr LoopMetadataConversion::convert() {
-  if (failed(initPropertyMap()))
+  if (failed(initState()))
     return {};
 
   FailureOr<BoolAttr> disableNonForced =
       lookupUnitNode("llvm.loop.disable_nonforced");
   FailureOr<LoopVectorizeAttr> vecAttr = convertVectorizeAttr();
   FailureOr<LoopInterleaveAttr> interleaveAttr = convertInterleaveAttr();
   FailureOr<LoopUnrollAttr> unrollAttr = convertUnrollAttr();
   FailureOr<LoopUnrollAndJamAttr> unrollAndJamAttr = convertUnrollAndJamAttr();
LoopAnnotationAttr LoopMetadataConversion::convert() {
 
   // Drop the metadata if there are parts that cannot be imported.
   if (!propertyMap.empty()) {
     for (auto name : propertyMap.keys())
       emitWarning(loc) << "unknown loop annotation " << name;
     return {};
   }
 
+  FailureOr<FusedLoc> startLoc = convertStartLoc();
+  FailureOr<FusedLoc> endLoc = convertEndLoc();
+
   return createIfNonNull<LoopAnnotationAttr>(
       ctx, disableNonForced, vecAttr, interleaveAttr, unrollAttr,
       unrollAndJamAttr, licmAttr, distributeAttr, pipelineAttr, peeledAttr,
-      unswitchAttr, mustProgress, isVectorized, parallelAccesses);
+      unswitchAttr, mustProgress, isVectorized, parallelAccesses, startLoc,
+      endLoc);
 }
 
 LoopAnnotationAttr
 LoopAnnotationImporter::translateLoopAnnotation(const llvm::MDNode *node,
                                                 Location loc) {
   if (!node)
     return {};
 

mlir/lib/Target/LLVMIR/LoopAnnotationTranslation.h

 namespace mlir {
 namespace LLVM {
 namespace detail {
 
 /// A helper class that converts LoopAnnotationAttrs and AccessGroupMetadataOps
 /// into a corresponding llvm::MDNodes.
 class LoopAnnotationTranslation {
 public:
-  LoopAnnotationTranslation(Operation *mlirModule, llvm::Module &llvmModule)
-      : mlirModule(mlirModule), llvmModule(llvmModule) {}
+  LoopAnnotationTranslation(ModuleTranslation &moduleTranslation,
+                            Operation *mlirModule, llvm::Module &llvmModule)
+      : moduleTranslation(moduleTranslation), mlirModule(mlirModule),
+        llvmModule(llvmModule) {}
 
   llvm::MDNode *translateLoopAnnotation(LoopAnnotationAttr attr, Operation *op);
 
   /// Traverses the global access group metadata operation in the `mlirModule`
   /// and creates corresponding LLVM metadata nodes.
   LogicalResult createAccessGroupMetadata();
 
   /// Returns the LLVM metadata corresponding to a symbol reference to an mlir
   /// LLVM dialect access group operation.
   llvm::MDNode *getAccessGroup(Operation *op,
                                SymbolRefAttr accessGroupRef) const;
 
   /// Returns the LLVM metadata corresponding to the access group operations
   /// referenced by the AccessGroupOpInterface or null if there are none.
   llvm::MDNode *getAccessGroups(AccessGroupOpInterface op) const;
 
+  /// The ModuleTranslation owning this instance.
+  ModuleTranslation &moduleTranslation;
+
 private:
   /// Returns the LLVM metadata corresponding to a llvm loop metadata attribute.
   llvm::MDNode *lookupLoopMetadata(Attribute options) const {
     return loopMetadataMapping.lookup(options);
   }
 
   void mapLoopMetadata(Attribute options, llvm::MDNode *metadata) {
     auto result = loopMetadataMapping.try_emplace(options, metadata);

mlir/lib/Target/LLVMIR/LoopAnnotationTranslation.cpp

 //===- LoopAnnotationTranslation.cpp - Loop annotation export -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LoopAnnotationTranslation.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 using namespace mlir::LLVM::detail;
 
 namespace {
 /// Helper class that keeps the state of one attribute to metadata conversion.
 struct LoopAnnotationConversion {
struct LoopAnnotationConversion {
 
   /// Conversion functions for different payload attribute kinds.
   void addUnitNode(StringRef name);
   void addUnitNode(StringRef name, BoolAttr attr);
   void addI32NodeWithVal(StringRef name, uint32_t val);
   void convertBoolNode(StringRef name, BoolAttr attr, bool negated = false);
   void convertI32Node(StringRef name, IntegerAttr attr);
   void convertFollowupNode(StringRef name, LoopAnnotationAttr attr);
+  void convertLocation(FusedLoc attr);
 
   /// Conversion functions for each for each loop annotation sub-attribute.
   void convertLoopOptions(LoopVectorizeAttr options);
   void convertLoopOptions(LoopInterleaveAttr options);
   void convertLoopOptions(LoopUnrollAttr options);
   void convertLoopOptions(LoopUnrollAndJamAttr options);
   void convertLoopOptions(LoopLICMAttr options);
   void convertLoopOptions(LoopDistributeAttr options);
void LoopAnnotationConversion::convertLoopOptions(LoopPeeledAttr options) {
   convertI32Node("llvm.loop.peeled.count", options.getCount());
 }
 
 void LoopAnnotationConversion::convertLoopOptions(LoopUnswitchAttr options) {
   addUnitNode("llvm.loop.unswitch.partial.disable",
               options.getPartialDisable());
 }
 
-llvm::MDNode *LoopAnnotationConversion::convert() {
+void LoopAnnotationConversion::convertLocation(FusedLoc location) {
+  auto localScopeAttr =
+      location.getMetadata().dyn_cast_or_null<DILocalScopeAttr>();
+  if (!localScopeAttr)
+    return;
+  auto *localScope = dyn_cast<llvm::DILocalScope>(
+      loopAnnotationTranslation.moduleTranslation.translateDebugInfo(
+          localScopeAttr));
+  if (!localScope)
+    return;
+  const llvm::Metadata *loc =
+      loopAnnotationTranslation.moduleTranslation.translateLoc(location,
+                                                               localScope);
+  metadataNodes.push_back(const_cast<llvm::Metadata *>(loc));
+}
 
+llvm::MDNode *LoopAnnotationConversion::convert() {
   // Reserve operand 0 for loop id self reference.
   auto dummy = llvm::MDNode::getTemporary(ctx, std::nullopt);
   metadataNodes.push_back(dummy.get());
 
+  if (FusedLoc startLoc = attr.getStartLoc())
+    convertLocation(startLoc);
+
+  if (FusedLoc endLoc = attr.getEndLoc())
+    convertLocation(endLoc);
+
   addUnitNode("llvm.loop.disable_nonforced", attr.getDisableNonforced());
   addUnitNode("llvm.loop.mustprogress", attr.getMustProgress());
   // "isvectorized" is encoded as an i32 value.
   if (BoolAttr isVectorized = attr.getIsVectorized())
     addI32NodeWithVal("llvm.loop.isvectorized", isVectorized.getValue());
 
   if (auto options = attr.getVectorize())
     convertLoopOptions(options);

mlir/lib/Target/LLVMIR/ModuleImport.cpp

 ModuleImport::ModuleImport(ModuleOp mlirModule,
                            std::unique_ptr<llvm::Module> llvmModule)
     : builder(mlirModule->getContext()), context(mlirModule->getContext()),
       mlirModule(mlirModule), llvmModule(std::move(llvmModule)),
       iface(mlirModule->getContext()),
       typeTranslator(*mlirModule->getContext()),
       debugImporter(std::make_unique<DebugImporter>(mlirModule)),
       loopAnnotationImporter(
-          std::make_unique<LoopAnnotationImporter>(builder)) {
+          std::make_unique<LoopAnnotationImporter>(*this, builder)) {
   builder.setInsertionPointToStart(mlirModule.getBody());
 }
 
 MetadataOp ModuleImport::getGlobalMetadataOp() {
   if (globalMetadataOp)
     return globalMetadataOp;
 
   OpBuilder::InsertionGuard guard(builder);

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 }
 
 ModuleTranslation::ModuleTranslation(Operation *module,
                                      std::unique_ptr<llvm::Module> llvmModule)
     : mlirModule(module), llvmModule(std::move(llvmModule)),
       debugTranslation(
           std::make_unique<DebugTranslation>(module, *this->llvmModule)),
       loopAnnotationTranslation(std::make_unique<LoopAnnotationTranslation>(
-          module, *this->llvmModule)),
+          *this, module, *this->llvmModule)),
       typeTranslator(this->llvmModule->getContext()),
       iface(module->getContext()) {
   assert(satisfiesLLVMModule(mlirModule) &&
          "mlirModule should honor LLVM's module semantics.");
 }
 
 ModuleTranslation::~ModuleTranslation() {
   if (ompBuilder)

mlir/test/Dialect/LLVMIR/loop-metadata.mlir

-// RUN: mlir-opt %s | mlir-opt | FileCheck %s
+// RUN: mlir-opt %s --split-input-file | mlir-opt --split-input-file | FileCheck %s
 
 // CHECK-DAG: #[[FOLLOWUP:.*]] = #llvm.loop_annotation<disableNonforced = true>
 #followup = #llvm.loop_annotation<disableNonforced = true>
 
 // CHECK-DAG: #[[VECTORIZE:.*]] = #llvm.loop_vectorize<disable = false, predicateEnable = false, scalableEnable = true, width = 16 : i32, followupVectorized = #[[FOLLOWUP]], followupEpilogue = #[[FOLLOWUP]], followupAll = #[[FOLLOWUP]]>
 #vectorize = #llvm.loop_vectorize<
   disable = false, predicateEnable = false, scalableEnable = true, width = 16 : i32,
   followupVectorized = #followup, followupEpilogue = #followup, followupAll = #followup

 ^bb1:
   llvm.return
 }
 
 llvm.metadata @metadata {
   llvm.access_group @group1
   llvm.access_group @group2
 }
+
+// -----
+
+#di_file = #llvm.di_file<"metadata-loop.ll" in "/">
+
+// CHECK: #[[START_LOC:.*]] = loc("loop-metadata.mlir":42:4)
+#loc1 = loc("loop-metadata.mlir":42:4)
+// CHECK: #[[END_LOC:.*]] = loc("loop-metadata.mlir":52:4)
+#loc2 = loc("loop-metadata.mlir":52:4)
+
+#di_compile_unit = #llvm.di_compile_unit<sourceLanguage = DW_LANG_C, file = #di_file, isOptimized = false, emissionKind = None>
+// CHECK: #[[SUBPROGRAM:.*]] = #llvm.di_subprogram<
+#di_subprogram = #llvm.di_subprogram<compileUnit = #di_compile_unit, scope = #di_file, name = "loop_locs", file = #di_file, subprogramFlags = Definition>
+
+// CHECK: #[[START_LOC_FUSED:.*]] = loc(fused<#[[SUBPROGRAM]]>[#[[START_LOC]]]
+#start_loc_fused = loc(fused<#di_subprogram>[#loc1])
+// CHECK: #[[END_LOC_FUSED:.*]] = loc(fused<#[[SUBPROGRAM]]>[#[[END_LOC]]]
+#end_loc_fused= loc(fused<#di_subprogram>[#loc2])
+
+// CHECK: #[[LOOP_ANNOT:.*]] = #llvm.loop_annotation<
+// CHECK-DAG: disableNonforced = false
+// CHECK-DAG: startLoc = #[[START_LOC_FUSED]]
+// CHECK-DAG: endLoc = #[[END_LOC_FUSED]]
+#loopMD = #llvm.loop_annotation<disableNonforced = false,
+        mustProgress = true,
+        startLoc = #start_loc_fused,
+        endLoc = #end_loc_fused>
+
+// CHECK: llvm.func @loop_annotation_with_locs
+llvm.func @loop_annotation_with_locs() {
+  // CHECK: llvm.br ^bb1 {llvm.loop = #[[LOOP_ANNOT]]
+  llvm.br ^bb1 {loop_annotation = #loopMD}
+^bb1:
+  llvm.return
+}

mlir/test/Target/LLVMIR/Import/metadata-loop.ll

 end:
   ret void
 }
 
 !0 = distinct !{}
 !1 = distinct !{!1, !2}
 !2 = !{!"llvm.loop.parallel_accesses", !0, !3}
 !3 = distinct !{}
+
+; // -----
+
+; CHECK: #[[start_loc:.*]] = loc("metadata-loop.ll":1:2)
+; CHECK: #[[end_loc:.*]] = loc("metadata-loop.ll":2:2)
+; CHECK: #[[SUBPROGRAM:.*]] = #llvm.di_subprogram<
+; CHECK: #[[start_loc_fused:.*]] = loc(fused<#[[SUBPROGRAM]]>[#[[start_loc]]])
+; CHECK: #[[end_loc_fused:.*]] = loc(fused<#[[SUBPROGRAM]]>[#[[end_loc]]])
+; CHECK: #[[$ANNOT_ATTR:.*]] = #llvm.loop_annotation<
+; CHECK-SAME: mustProgress = true
+; CHECK-SAME: startLoc = #[[start_loc_fused]]
+; CHECK-SAME: endLoc = #[[end_loc_fused]]
+
+; CHECK-LABEL: @loop_locs
+define void @loop_locs(i64 %n, ptr %A) {
+entry:
+; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+  br label %end, !llvm.loop !6
+end:
+  ret void
+}
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!0}
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2)
+!2 = !DIFile(filename: "metadata-loop.ll", directory: "/")
+!3 = distinct !DISubprogram(name: "loop_locs", scope: !2, file: !2, spFlags: DISPFlagDefinition, unit: !1)
+!4 = !DILocation(line: 1, column: 2, scope: !3)
+!5 = !DILocation(line: 2, column: 2, scope: !3)
+
+!6 = distinct !{!6, !4, !5, !7}
+!7 = !{!"llvm.loop.mustprogress"}

mlir/test/Target/LLVMIR/loop-metadata.mlir

 // CHECK-DAG: ![[GROUP_NODE1:[0-9]+]] = distinct !{}
 // CHECK-DAG: ![[GROUP_NODE2:[0-9]+]] = distinct !{}
 // CHECK-DAG: ![[UNROLL_DISABLE_NODE:[0-9]+]] = !{!"llvm.loop.unroll.disable"}
 // CHECK-DAG: ![[LICM_DISABLE_NODE:[0-9]+]] = !{!"llvm.licm.disable"}
 // CHECK-DAG: ![[INTERLEAVE_NODE:[0-9]+]] = !{!"llvm.loop.interleave.count", i32 1}
 // CHECK-DAG: ![[PIPELINE_DISABLE_NODE:[0-9]+]] = !{!"llvm.loop.pipeline.disable", i1 true}
 // CHECK-DAG: ![[II_NODE:[0-9]+]] = !{!"llvm.loop.pipeline.initiationinterval", i32 2}
 // CHECK-DAG: ![[ACCESS_GROUPS_NODE:[0-9]+]] = !{![[GROUP_NODE1]], ![[GROUP_NODE2]]}
+
+// -----
+
+#di_file = #llvm.di_file<"metadata-loop.ll" in "/">
+
+#loc1 = loc("loop-metadata.mlir":42:4)
+#loc2 = loc("loop-metadata.mlir":52:4)
+
+#di_compile_unit = #llvm.di_compile_unit<sourceLanguage = DW_LANG_C, file = #di_file, isOptimized = false, emissionKind = None>
+#di_subprogram = #llvm.di_subprogram<compileUnit = #di_compile_unit, scope = #di_file, name = "loop_locs", file = #di_file, subprogramFlags = Definition>
+
+#start_loc_fused = loc(fused<#di_subprogram>[#loc1])
+#end_loc_fused= loc(fused<#di_subprogram>[#loc2])
+
+#loopMD = #llvm.loop_annotation<disableNonforced = false,
+        mustProgress = true,
+        startLoc = #start_loc_fused,
+        endLoc = #end_loc_fused>
+
+// CHECK-LABEL: @loop_annotation_with_locs
+llvm.func @loop_annotation_with_locs() {
+// CHECK: br i1 {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
+  llvm.br ^bb1 {loop_annotation = #loopMD}
+^bb1:
+  llvm.return
+}