CodeGen: Add a target option for emitting .addrsig directives for all address-significant symbols.

[pcc]

Summary

Depends on D47744

[pcc]

Ping.

[echristo]

LGTM. Not a fan of adding more stuff to TargetOptions, but for now it'll do.

llvm/include/llvm/CodeGen/CommandFlags.inc

static cl::opt<DebuggerKind> DebuggerTuningOpt(
     cl::values(clEnumValN(DebuggerKind::GDB, "gdb", "gdb"),
                clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"),
                clEnumValN(DebuggerKind::SCE, "sce", "SCE targets (e.g. PS4)")));
 
 static cl::opt<bool> EnableStackSizeSection(
     "stack-size-section",
     cl::desc("Emit a section containing stack size metadata"), cl::init(false));
 
+static cl::opt<bool>
+    EnableAddrsig("addrsig", cl::desc("Emit an address-significance table"),
+                  cl::init(false));
+
 // Common utility function tightly tied to the options listed here. Initializes
 // a TargetOptions object with CodeGen flags and returns it.
 static TargetOptions InitTargetOptionsFromCodeGenFlags() {
   TargetOptions Options;
   Options.AllowFPOpFusion = FuseFPOps;
   Options.UnsafeFPMath = EnableUnsafeFPMath;
   Options.NoInfsFPMath = EnableNoInfsFPMath;
   Options.NoNaNsFPMath = EnableNoNaNsFPMath;
static TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.RelaxELFRelocations = RelaxELFRelocations;
   Options.DataSections = DataSections;
   Options.FunctionSections = FunctionSections;
   Options.UniqueSectionNames = UniqueSectionNames;
   Options.EmulatedTLS = EmulatedTLS;
   Options.ExplicitEmulatedTLS = EmulatedTLS.getNumOccurrences() > 0;
   Options.ExceptionModel = ExceptionModel;
   Options.EmitStackSizeSection = EnableStackSizeSection;
+  Options.EmitAddrsig = EnableAddrsig;
 
   Options.MCOptions = InitMCTargetOptionsFromFlags();
 
   Options.ThreadModel = TMModel;
   Options.EABIVersion = EABIVersion;
   Options.DebuggerTuning = DebuggerTuningOpt;
 
   return Options;

llvm/include/llvm/Target/TargetOptions.h

TargetOptions()
         : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
           NoNaNsFPMath(false), NoTrappingFPMath(false),
           NoSignedZerosFPMath(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
           EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
           DisableIntegratedAS(false), RelaxELFRelocations(false),
           FunctionSections(false), DataSections(false),
-          UniqueSectionNames(true), TrapUnreachable(false),
-          EmulatedTLS(false), ExplicitEmulatedTLS(false),
-          EnableIPRA(false), EmitStackSizeSection(false) {}
+          UniqueSectionNames(true), TrapUnreachable(false), EmulatedTLS(false),
+          ExplicitEmulatedTLS(false), EnableIPRA(false),
+          EmitStackSizeSection(false), EmitAddrsig(false) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
     /// output from the code generator.
     unsigned PrintMachineCode : 1;
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
public:
     unsigned ExplicitEmulatedTLS : 1;
 
     /// This flag enables InterProcedural Register Allocation (IPRA).
     unsigned EnableIPRA : 1;
 
     /// Emit section containing metadata on function stack sizes.
     unsigned EmitStackSizeSection : 1;
 
+    /// Emit address-significance table.
+    unsigned EmitAddrsig : 1;
+
     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
     /// on the command line. This setting may either be Default, Soft, or Hard.
     /// Default selects the target's default behavior. Soft selects the ABI for
     /// software floating point, but does not indicate that FP hardware may not
     /// be used. Such a combination is unfortunately popular (e.g.
     /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
     FloatABI::ABIType FloatABIType = FloatABI::Default;
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (const auto *LU = M.getNamedGlobal("llvm.used")) {
             OutStreamer->EmitBytes(Flags);
           }
           Flags.clear();
         }
       }
     }
   }
 
+  if (TM.Options.EmitAddrsig) {
+    // Emit address-significance attributes for all globals.
+    OutStreamer->EmitAddrsig();
+    for (const GlobalValue &GV : M.global_values())
+      if (!GV.getName().startswith("llvm.") && !GV.hasAtLeastLocalUnnamedAddr())
+        OutStreamer->EmitAddrsigSym(getSymbol(&GV));
+  }
+
   // Allow the target to emit any magic that it wants at the end of the file,
   // after everything else has gone out.
   EmitEndOfAsmFile(M);
 
   MMI = nullptr;
 
   OutStreamer->Finish();
   OutStreamer->reset();

llvm/test/CodeGen/X86/addrsig.ll

+; RUN: llc < %s -mtriple=x86_64-unknown-linux | FileCheck --check-prefix=NO-ADDRSIG %s
+; RUN: llc < %s -mtriple=x86_64-unknown-linux -addrsig | FileCheck %s
+
+; NO-ADDRSIG-NOT: .addrsig
+
+; CHECK: .addrsig
+
+; CHECK: .addrsig_sym f1
+define void @f1() {
+  unreachable
+}
+
+; CHECK-NOT: .addrsig_sym f2
+define internal void @f2() local_unnamed_addr {
+  unreachable
+}
+
+; CHECK-NOT: .addrsig_sym f3
+declare void @f3() unnamed_addr
+
+; CHECK: .addrsig_sym g1
+@g1 = global i32 0
+; CHECK-NOT: .addrsig_sym g2
+@g2 = internal local_unnamed_addr global i32 0
+; CHECK-NOT: .addrsig_sym g3
+@g3 = external unnamed_addr global i32
+
+; CHECK: .addrsig_sym a1
+@a1 = alias i32, i32* @g1
+; CHECK-NOT: .addrsig_sym a2
+@a2 = internal local_unnamed_addr alias i32, i32* @g2
+
+; CHECK: .addrsig_sym i1
+@i1 = ifunc void(), void()* @f1
+; CHECK-NOT: .addrsig_sym i2
+@i2 = internal local_unnamed_addr ifunc void(), void()* @f2