Rename KeepFramePointer to EnableBacktraces, and add UWTableKind to default in that case. Also enable that feature when Target::Feature::Debug is set. Cleanup some helper functions.

Author: mcourteaux

src/CodeGen_Internal.cpp

@@ -588,17 +588,27 @@ std::optional<std::string> get_md_string(llvm::Metadata *value) {
     }
     return std::nullopt;
 }
+
+bool get_modflag_bool(const llvm::Module &mod, const char *flag, bool or_default = false) {
+    return get_md_bool(mod.getModuleFlag(flag)).value_or(or_default);
+}
+
+int get_modflag_int(const llvm::Module &mod, const char *flag, int or_default = 0) {
+    return get_md_int(mod.getModuleFlag(flag)).value_or(or_default);
+}
+
+std::string get_modflag_string(const llvm::Module &mod, const char *flag, std::string or_default = {}) {
+    return get_md_string(mod.getModuleFlag(flag)).value_or(or_default);
+}
+
 }  // namespace
 
 void get_target_options(const llvm::Module &module, llvm::TargetOptions &options) {
-    bool use_soft_float_abi =
-        get_md_bool(module.getModuleFlag("halide_use_soft_float_abi")).value_or(false);
-    std::string mabi =
-        get_md_string(module.getModuleFlag("halide_mabi")).value_or(std::string{});
+    bool use_soft_float_abi = get_modflag_bool(module, "halide_use_soft_float_abi");
+    std::string mabi = get_modflag_string(module, "halide_mabi");
 
     // FIXME: can this be migrated into `set_function_attributes_from_halide_target_options()`?
-    bool per_instruction_fast_math_flags =
-        get_md_bool(module.getModuleFlag("halide_per_instruction_fast_math_flags")).value_or(false);
+    bool per_instruction_fast_math_flags = get_modflag_bool(module, "halide_per_instruction_fast_math_flags");
 
     options = llvm::TargetOptions();
     options.AllowFPOpFusion = per_instruction_fast_math_flags ? llvm::FPOpFusion::Strict : llvm::FPOpFusion::Fast;
@@ -610,8 +620,7 @@ void get_target_options(const llvm::Module &module, llvm::TargetOptions &options
     options.GuaranteedTailCallOpt = false;
     options.FunctionSections = true;
     options.UseInitArray = true;
-    options.FloatABIType =
-        use_soft_float_abi ? llvm::FloatABI::Soft : llvm::FloatABI::Hard;
+    options.FloatABIType = use_soft_float_abi ? llvm::FloatABI::Soft : llvm::FloatABI::Hard;
 #if LLVM_VERSION >= 190
     options.MCOptions.X86RelaxRelocations = false;
 #else
@@ -628,7 +637,7 @@ void clone_target_options(const llvm::Module &from, llvm::Module &to) {
     // Clone bool metadata
     for (const char *s : {"halide_use_soft_float_abi",
                           "halide_use_pic",
-                          "halide_keep_frame_pointer"}) {
+                          "halide_enable_backtraces"}) {
         if (auto md = get_md_bool(from.getModuleFlag(s))) {
             to.addModuleFlag(llvm::Module::Warning, s, *md ? 1 : 0);
         }
@@ -659,17 +668,12 @@ std::unique_ptr<llvm::TargetMachine> make_target_machine(const llvm::Module &mod
     llvm::TargetOptions options;
     get_target_options(module, options);
 
-    bool use_pic =
-        get_md_bool(module.getModuleFlag("halide_use_pic")).value_or(true);
-
-    bool use_large_code_model =
-        get_md_bool(module.getModuleFlag("halide_use_large_code_model")).value_or(false);
+    bool use_pic = get_modflag_bool(module, "halide_use_pic", true);
+    bool use_large_code_model = get_modflag_bool(module, "halide_use_large_code_model");
 
     // Get module mcpu_target and mattrs.
-    std::string mcpu_target =
-        get_md_string(module.getModuleFlag("halide_mcpu_target")).value_or(std::string{});
-    std::string mattrs =
-        get_md_string(module.getModuleFlag("halide_mattrs")).value_or(std::string{});
+    std::string mcpu_target = get_modflag_string(module, "halide_mcpu_target");
+    std::string mattrs = get_modflag_string(module, "halide_mattrs");
 
     auto *tm = llvm_target->createTargetMachine(
 #if LLVM_VERSION >= 210
@@ -689,17 +693,18 @@ std::unique_ptr<llvm::TargetMachine> make_target_machine(const llvm::Module &mod
 void set_function_attributes_from_halide_target_options(llvm::Function &fn) {
     llvm::Module &module = *fn.getParent();
 
-    std::string mcpu_target = get_md_string(module.getModuleFlag("halide_mcpu_target")).value_or(std::string{});
-    std::string mcpu_tune = get_md_string(module.getModuleFlag("halide_mcpu_tune")).value_or(std::string{});
-    std::string mattrs = get_md_string(module.getModuleFlag("halide_mattrs")).value_or(std::string{});
-    int64_t vscale_range = get_md_int(module.getModuleFlag("halide_effective_vscale")).value_or(0);
-    bool keep_fp = get_md_int(module.getModuleFlag("halide_keep_frame_pointer")).value_or(0);
+    std::string mcpu_target = get_modflag_string(module, "halide_mcpu_target");
+    std::string mcpu_tune = get_modflag_string(module, "halide_mcpu_tune");
+    std::string mattrs = get_modflag_string(module, "halide_mattrs");
+    int64_t vscale_range = get_modflag_int(module, "halide_effective_vscale");
+    bool enable_bt = get_modflag_int(module, "halide_enable_backtraces");
 
     fn.addFnAttr("target-cpu", mcpu_target);
     fn.addFnAttr("tune-cpu", mcpu_tune);
     fn.addFnAttr("target-features", mattrs);
-    if (keep_fp) {
+    if (enable_bt) {
         fn.addFnAttr("frame-pointer", "all");
+        fn.setUWTableKind(llvm::UWTableKind::Default);
     }
 
     // Halide-generated IR is not exception-safe.

src/CodeGen_LLVM.cpp

@@ -401,7 +401,9 @@ void CodeGen_LLVM::init_codegen(const std::string &name) {
     module->setModuleIdentifier(name);
 
     // Add some target specific info to the module as metadata.
-    module->addModuleFlag(llvm::Module::Warning, "halide_keep_frame_pointer", target.has_feature(Target::Feature::KeepFramePointer) ? 1 : 0);
+    bool enable_bt = target.has_feature(Target::Feature::EnableBacktraces) ||
+                     target.has_feature(Target::Feature::Debug);
+    module->addModuleFlag(llvm::Module::Warning, "halide_enable_backtraces", enable_bt ? 1 : 0);
     module->addModuleFlag(llvm::Module::Warning, "halide_use_soft_float_abi", use_soft_float_abi() ? 1 : 0);
     module->addModuleFlag(llvm::Module::Warning, "halide_mcpu_target", MDString::get(*context, mcpu_target()));
     module->addModuleFlag(llvm::Module::Warning, "halide_mcpu_tune", MDString::get(*context, mcpu_tune()));

src/Target.cpp

@@ -646,7 +646,7 @@ bool lookup_processor(const std::string &tok, Target::Processor &result) {
 const std::map<std::string, Target::Feature> feature_name_map = {
     {"jit", Target::JIT},
     {"debug", Target::Debug},
-    {"keep_frame_pointer", Target::KeepFramePointer},
+    {"enable_backtraces", Target::EnableBacktraces},
     {"no_asserts", Target::NoAsserts},
     {"no_bounds_query", Target::NoBoundsQuery},
     {"sse41", Target::SSE41},

src/Target.h

@@ -84,7 +84,7 @@ struct Target {
     enum Feature {
         JIT = halide_target_feature_jit,
         Debug = halide_target_feature_debug,
-        KeepFramePointer = halide_target_feature_keep_frame_pointer,
+        EnableBacktraces = halide_target_feature_enable_backtraces,
         NoAsserts = halide_target_feature_no_asserts,
         NoBoundsQuery = halide_target_feature_no_bounds_query,
         SSE41 = halide_target_feature_sse41,

src/runtime/HalideRuntime.h

@@ -1355,11 +1355,11 @@ extern int halide_error_vscale_invalid(void *user_context, const char *func_name
  * get_runtime_compatible_target in Target.cpp if you add a new feature.
  */
 typedef enum halide_target_feature_t {
-    halide_target_feature_jit = 0,             ///< Generate code that will run immediately inside the calling process.
-    halide_target_feature_debug,               ///< Turn on debug info and output for runtime code.
-    halide_target_feature_keep_frame_pointer,  ///< Keep the frame pointer in tact in functions produced by LLVM.
-    halide_target_feature_no_asserts,          ///< Disable all runtime checks, for slightly tighter code.
-    halide_target_feature_no_bounds_query,     ///< Disable the bounds querying functionality.
+    halide_target_feature_jit = 0,            ///< Generate code that will run immediately inside the calling process.
+    halide_target_feature_debug,              ///< Turn on debug info and output for runtime code.
+    halide_target_feature_enable_backtraces,  ///< Keep the frame pointer in tact in functions produced by LLVM.
+    halide_target_feature_no_asserts,         ///< Disable all runtime checks, for slightly tighter code.
+    halide_target_feature_no_bounds_query,    ///< Disable the bounds querying functionality.
 
     halide_target_feature_sse41,    ///< Use SSE 4.1 and earlier instructions. Only relevant on x86.
     halide_target_feature_avx,      ///< Use AVX 1 instructions. Only relevant on x86.