Define __GCC_HAVE_DWARF2_CFI_ASM if applicable

[MaskRay]

Summary

In -fno-exceptions -fno-asynchronous-unwind-tables -g0 mode,
GCC does not emit .cfi_* directives.

% diff <(gcc -fno-asynchronous-unwind-tables -dM -E a.c) <(gcc -dM -E a.c)
130a131
> #define __GCC_HAVE_DWARF2_CFI_ASM 1

This macro is useful because code can decide whether inline asm should include .cfi_* directives.
.cfi_* directives without .cfi_startproc can cause assembler errors.

[MaskRay]

Check -g and exceptions

[MaskRay]

@jansvoboda11 :)

[jansvoboda11]

Could the logic be implemented in the driver?

LGTM regardless.

[MaskRay]

In D97743#2613629, @jansvoboda11 wrote:

Could the logic be implemented in the driver?

LGTM regardless.

No. Res is a clang::CompilerInvocation object. CompilerInvocation is not in the driver... -D -U and __CET__ are implemented in this file, too.

[thakis]

This seems to break tests everywhere: http://45.33.8.238/linux/41275/step_7.txt

[MaskRay]

In D97743#2614792, @thakis wrote:

This seems to break tests everywhere: http://45.33.8.238/linux/41275/step_7.txt

My bad. Fixed by df67d3526962ae51446b1390e7c40e045e580ec2

[thakis]

Still broken: http://45.33.8.238/linux/41278/step_7.txt

[MaskRay]

In D97743#2614827, @thakis wrote:

Still broken: http://45.33.8.238/linux/41278/step_7.txt

b4948c27d2e40586c0c4fa7cbf20b9c40a9f7584

The green Harbomaster misled me..

[jansvoboda11]

In D97743#2614480, @MaskRay wrote:

In D97743#2613629, @jansvoboda11 wrote:

Could the logic be implemented in the driver?

LGTM regardless.

No. Res is a clang::CompilerInvocation object. CompilerInvocation is not in the driver... -D -U and __CET__ are implemented in this file, too.

Right. I meant if it would be possible to move the logic to the driver and pass -D__GCC_HAVE_DWARF2_CFI_ASM=1 explicitly from the driver to -cc1, keeping CompilerInvocation as simple as possible.

[MaskRay]

Move to driver

[jansvoboda11]

In D97743#2614899, @MaskRay wrote:

Move to driver

Thanks!

[MaskRay]

There are some side effects: because -D is passed as command line options, it has <command line> in its filename, so isWrittenInBuiltinFile will not match it (isWrittenInBuiltinFile can match other built-in macros)...

clang/lib/Driver/ToolChains/Clang.cpp

return (!Triple.isMacOSXVersionLT(10, 5) &&
           (Triple.getArch() == llvm::Triple::x86_64 ||
            Triple.getArch() == llvm::Triple::arm));
 }
 
 /// Adds exception related arguments to the driver command arguments. There's a
 /// master flag, -fexceptions and also language specific flags to enable/disable
 /// C++ and Objective-C exceptions. This makes it possible to for example
 /// disable C++ exceptions but enable Objective-C exceptions.
-static void addExceptionArgs(const ArgList &Args, types::ID InputType,
+static bool addExceptionArgs(const ArgList &Args, types::ID InputType,
                              const ToolChain &TC, bool KernelOrKext,
                              const ObjCRuntime &objcRuntime,
                              ArgStringList &CmdArgs) {
   const llvm::Triple &Triple = TC.getTriple();
 
   if (KernelOrKext) {
     // -mkernel and -fapple-kext imply no exceptions, so claim exception related
     // arguments now to avoid warnings about unused arguments.
     Args.ClaimAllArgs(options::OPT_fexceptions);
     Args.ClaimAllArgs(options::OPT_fno_exceptions);
     Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
     Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
     Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
     Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
-    return;
+    return false;
   }
 
   // See if the user explicitly enabled exceptions.
   bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
                          false);
 
   // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
   // is not necessarily sensible, but follows GCC.
static bool addExceptionArgs(const ArgList &Args, types::ID InputType,
 
   // OPT_fignore_exceptions means exception could still be thrown,
   // but no clean up or catch would happen in current module.
   // So we do not set EH to false.
   Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
 
   if (EH)
     CmdArgs.push_back("-fexceptions");
+  return EH;
 }
 
 static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC,
                                  const JobAction &JA) {
   bool Default = true;
   if (TC.getTriple().isOSDarwin()) {
     // The native darwin assembler doesn't support the linker_option directives,
     // so we disable them if we think the .s file will be passed to it.
bool Freestanding =
       Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
       KernelOrKext;
   if (Freestanding)
     CmdArgs.push_back("-ffreestanding");
 
   // This is a coarse approximation of what llvm-gcc actually does, both
   // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
   // complicated ways.
-  bool AsynchronousUnwindTables =
+  bool UnwindTables =
       Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
                    options::OPT_fno_asynchronous_unwind_tables,
                    (TC.IsUnwindTablesDefault(Args) ||
                     TC.getSanitizerArgs().needsUnwindTables()) &&
                        !Freestanding);
-  if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
-                   AsynchronousUnwindTables))
+  UnwindTables = Args.hasFlag(options::OPT_funwind_tables,
+                              options::OPT_fno_unwind_tables, UnwindTables);
+  if (UnwindTables)
     CmdArgs.push_back("-munwind-tables");
 
   // Prepare `-aux-target-cpu` and `-aux-target-feature` unless
   // `--gpu-use-aux-triple-only` is specified.
   if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
       ((IsCuda && JA.isDeviceOffloading(Action::OFK_Cuda)) ||
        (IsHIP && JA.isDeviceOffloading(Action::OFK_HIP)))) {
     const ArgList &HostArgs =
if (types::isObjC(Input.getType()) &&
                    !Runtime.isNeXTFamily()))
     CmdArgs.push_back("-fobjc-encode-cxx-class-template-spec");
 
   if (Args.hasFlag(options::OPT_fapplication_extension,
                    options::OPT_fno_application_extension, false))
     CmdArgs.push_back("-fapplication-extension");
 
   // Handle GCC-style exception args.
+  bool EH = false;
   if (!C.getDriver().IsCLMode())
-    addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
+    EH = addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
 
   // Handle exception personalities
   Arg *A = Args.getLastArg(
       options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
       options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
   if (A) {
     const Option &Opt = A->getOption();
     if (Opt.matches(options::OPT_fsjlj_exceptions))
if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
                    (TC.getTriple().isOSBinFormatELF() ||
                     TC.getTriple().isOSBinFormatCOFF()) &&
                        !TC.getTriple().isPS4() && !TC.getTriple().isVE() &&
                        !TC.getTriple().isOSNetBSD() &&
                        !Distro(D.getVFS(), TC.getTriple()).IsGentoo() &&
                        !TC.getTriple().isAndroid() && TC.useIntegratedAs()))
     CmdArgs.push_back("-faddrsig");
 
+  if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
+      (EH || UnwindTables || DebugInfoKind != codegenoptions::NoDebugInfo))
+    CmdArgs.push_back("-D__GCC_HAVE_DWARF2_CFI_ASM=1");
+
   if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
     std::string Str = A->getAsString(Args);
     if (!TC.getTriple().isOSBinFormatELF())
       D.Diag(diag::err_drv_unsupported_opt_for_target)
           << Str << TC.getTripleString();
     CmdArgs.push_back(Args.MakeArgString(Str));
   }
 

clang/test/Preprocessor/unwind-tables.c

+// RUN: %clang %s -dM -E -target x86_64-windows | FileCheck %s --check-prefix=NO
+// RUN: %clang %s -dM -E -target x86_64 -fno-asynchronous-unwind-tables | FileCheck %s --check-prefix=NO
+
+// RUN: %clang %s -dM -E -target x86_64 | FileCheck %s
+// RUN: %clang %s -dM -E -target aarch64-apple-darwin | FileCheck %s
+// RUN: %clang %s -dM -E -target x86_64 -fno-asynchronous-unwind-tables -g | FileCheck %s
+// RUN: %clang %s -dM -E -target x86_64 -fno-asynchronous-unwind-tables -fexceptions | FileCheck %s
+
+// NO-NOT: #define __GCC_HAVE_DWARF2_CFI_ASM
+// CHECK: #define __GCC_HAVE_DWARF2_CFI_ASM 1