Relro is missing from the original "#pragma clang section" implementation.

[dmikulin]

Summary

Added support for "#pragma clang section relro=<name>"

clang/docs/LanguageExtensions.rst

 
 The ``#pragma clang section`` directive provides a means to assign section-names
 to global variables, functions and static variables.
 
 The section names can be specified as:
 
 .. code-block:: c++
 
-  #pragma clang section bss="myBSS" data="myData" rodata="myRodata" text="myText"
+  #pragma clang section bss="myBSS" data="myData" rodata="myRodata" relro="myRelro" text="myText"
 
 The section names can be reverted back to default name by supplying an empty
 string to the section kind, for example:
 
 .. code-block:: c++
 
-  #pragma clang section bss="" data="" text="" rodata=""
+  #pragma clang section bss="" data="" text="" rodata="" relro=""
 
 The ``#pragma clang section`` directive obeys the following rules:
 
 * The pragma applies to all global variable, statics and function declarations
   from the pragma to the end of the translation unit.
 
 * The pragma clang section is enabled automatically, without need of any flags.
 

clang/include/clang/Basic/Attr.td

 def PragmaClangRodataSection : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let Args = [StringArgument<"Name">];
   let Subjects = SubjectList<[GlobalVar], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
+def PragmaClangRelroSection : InheritableAttr {
+  // This attribute has no spellings as it is only ever created implicitly.
+  let Spellings = [];
+  let Args = [StringArgument<"Name">];
+  let Subjects = SubjectList<[GlobalVar], ErrorDiag>;
+  let Documentation = [Undocumented];
+}
+
 def PragmaClangTextSection : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let Args = [StringArgument<"Name">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 

clang/include/clang/Basic/DiagnosticParseKinds.td

def warn_pragma_missing_argument : Warning<
   "missing argument to '#pragma %0'%select{|; expected %2}1">, InGroup<IgnoredPragmas>;
 def warn_pragma_invalid_argument : Warning<
   "unexpected argument '%0' to '#pragma %1'%select{|; expected %3}2">, InGroup<IgnoredPragmas>;
 
 def err_pragma_misplaced_in_decl : Error<"this pragma cannot appear in %0 declaration">;
 
 // '#pragma clang section' related errors
 def err_pragma_expected_clang_section_name : Error<
-  "expected one of [bss|data|rodata|text] section kind in '#pragma %0'">;
+  "expected one of [bss|data|rodata|text|relro] section kind in '#pragma %0'">;
 def err_pragma_clang_section_expected_equal : Error<
-  "expected '=' following '#pragma clang section %select{invalid|bss|data|rodata|text}0'">;
+  "expected '=' following '#pragma clang section %select{invalid|bss|data|rodata|text|relro}0'">;
 def warn_pragma_expected_section_name : Warning<
   "expected a string literal for the section name in '#pragma %0' - ignored">,
   InGroup<IgnoredPragmas>;
 
 def warn_pragma_expected_section_push_pop_or_name : Warning<
   "expected push, pop or a string literal for the section name in '#pragma %0' - ignored">,
   InGroup<IgnoredPragmas>;
 def warn_pragma_expected_section_label_or_name : Warning<

clang/include/clang/Sema/Sema.h

public:
   llvm::SmallVector<TypoExpr *, 2> TypoExprs;
 
   /// pragma clang section kind
   enum PragmaClangSectionKind {
     PCSK_Invalid      = 0,
     PCSK_BSS          = 1,
     PCSK_Data         = 2,
     PCSK_Rodata       = 3,
-    PCSK_Text         = 4
+    PCSK_Text         = 4,
+    PCSK_Relro        = 5
    };
 
   enum PragmaClangSectionAction {
     PCSA_Set     = 0,
     PCSA_Clear   = 1
   };
 
   struct PragmaClangSection {
     std::string SectionName;
     bool Valid = false;
     SourceLocation PragmaLocation;
 
     void Act(SourceLocation PragmaLocation,
              PragmaClangSectionAction Action,
              StringLiteral* Name);
    };
 
    PragmaClangSection PragmaClangBSSSection;
    PragmaClangSection PragmaClangDataSection;
    PragmaClangSection PragmaClangRodataSection;
+   PragmaClangSection PragmaClangRelroSection;
    PragmaClangSection PragmaClangTextSection;
 
   enum PragmaMsStackAction {
     PSK_Reset     = 0x0,                // #pragma ()
     PSK_Set       = 0x1,                // #pragma (value)
     PSK_Push      = 0x2,                // #pragma (push[, id])
     PSK_Pop       = 0x4,                // #pragma (pop[, id])
     PSK_Show      = 0x8,                // #pragma (show) -- only for "pack"!

clang/lib/CodeGen/CGDecl.cpp

if (D.hasAttr<AnnotateAttr>())
     CGM.AddGlobalAnnotations(&D, var);
 
   if (auto *SA = D.getAttr<PragmaClangBSSSectionAttr>())
     var->addAttribute("bss-section", SA->getName());
   if (auto *SA = D.getAttr<PragmaClangDataSectionAttr>())
     var->addAttribute("data-section", SA->getName());
   if (auto *SA = D.getAttr<PragmaClangRodataSectionAttr>())
     var->addAttribute("rodata-section", SA->getName());
+  if (auto *SA = D.getAttr<PragmaClangRelroSectionAttr>())
+    var->addAttribute("relro-section", SA->getName());
 
   if (const SectionAttr *SA = D.getAttr<SectionAttr>())
     var->setSection(SA->getName());
 
   if (D.hasAttr<UsedAttr>())
     CGM.addUsedGlobal(var);
 
   // We may have to cast the constant because of the initializer

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
   if (D) {
     if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
       if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>())
         GV->addAttribute("bss-section", SA->getName());
       if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>())
         GV->addAttribute("data-section", SA->getName());
       if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>())
         GV->addAttribute("rodata-section", SA->getName());
+      if (auto *SA = D->getAttr<PragmaClangRelroSectionAttr>())
+        GV->addAttribute("relro-section", SA->getName());
     }
 
     if (auto *F = dyn_cast<llvm::Function>(GO)) {
       if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>())
         if (!D->getAttr<SectionAttr>())
           F->addFnAttr("implicit-section-name", SA->getName());
 
       llvm::AttrBuilder Attrs;
static bool isVarDeclStrongDefinition(const ASTContext &Context,
   if (D->hasAttr<SectionAttr>())
     return true;
 
   // A variable cannot be both common and exist in a section.
   // We don't try to determine which is the right section in the front-end.
   // If no specialized section name is applicable, it will resort to default.
   if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
       D->hasAttr<PragmaClangDataSectionAttr>() ||
+      D->hasAttr<PragmaClangRelroSectionAttr>() ||
       D->hasAttr<PragmaClangRodataSectionAttr>())
     return true;
 
   // Thread local vars aren't considered common linkage.
   if (D->getTLSKind())
     return true;
 
   // Tentative definitions marked with WeakImportAttr are true definitions.

clang/lib/Parse/ParsePragma.cpp

void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
   Toks[0].setLocation(MSStructTok.getLocation());
   Toks[0].setAnnotationEndLoc(EndLoc);
   Toks[0].setAnnotationValue(reinterpret_cast<void*>(
                              static_cast<uintptr_t>(Kind)));
   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
                       /*IsReinject=*/false);
 }
 
-// #pragma clang section bss="abc" data="" rodata="def" text=""
+// #pragma clang section bss="abc" data="" rodata="def" text="" relro=""
 void PragmaClangSectionHandler::HandlePragma(Preprocessor &PP,
                                              PragmaIntroducer Introducer,
                                              Token &FirstToken) {
 
   Token Tok;
   auto SecKind = Sema::PragmaClangSectionKind::PCSK_Invalid;
 
   PP.Lex(Tok); // eat 'section'
   while (Tok.isNot(tok::eod)) {
     if (Tok.isNot(tok::identifier)) {
       PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section";
       return;
     }
 
     const IdentifierInfo *SecType = Tok.getIdentifierInfo();
     if (SecType->isStr("bss"))
       SecKind = Sema::PragmaClangSectionKind::PCSK_BSS;
     else if (SecType->isStr("data"))
       SecKind = Sema::PragmaClangSectionKind::PCSK_Data;
     else if (SecType->isStr("rodata"))
       SecKind = Sema::PragmaClangSectionKind::PCSK_Rodata;
+    else if (SecType->isStr("relro"))
+      SecKind = Sema::PragmaClangSectionKind::PCSK_Relro;
     else if (SecType->isStr("text"))
       SecKind = Sema::PragmaClangSectionKind::PCSK_Text;
     else {
       PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section";
       return;
     }
 
     PP.Lex(Tok); // eat ['bss'|'data'|'rodata'|'text']

clang/lib/Sema/SemaAttr.cpp

case PragmaClangSectionKind::PCSK_BSS:
       CSec = &PragmaClangBSSSection;
       break;
     case PragmaClangSectionKind::PCSK_Data:
       CSec = &PragmaClangDataSection;
       break;
     case PragmaClangSectionKind::PCSK_Rodata:
       CSec = &PragmaClangRodataSection;
       break;
+    case PragmaClangSectionKind::PCSK_Relro:
+      CSec = &PragmaClangRelroSection;
+      break;
     case PragmaClangSectionKind::PCSK_Text:
       CSec = &PragmaClangTextSection;
       break;
     default:
       llvm_unreachable("invalid clang section kind");
   }
 
   if (Action == PragmaClangSectionAction::PCSA_Clear) {

clang/lib/Sema/SemaDecl.cpp

if (PragmaClangDataSection.Valid)
           Context, PragmaClangDataSection.SectionName,
           PragmaClangDataSection.PragmaLocation,
           AttributeCommonInfo::AS_Pragma));
     if (PragmaClangRodataSection.Valid)
       VD->addAttr(PragmaClangRodataSectionAttr::CreateImplicit(
           Context, PragmaClangRodataSection.SectionName,
           PragmaClangRodataSection.PragmaLocation,
           AttributeCommonInfo::AS_Pragma));
+    if (PragmaClangRelroSection.Valid)
+      VD->addAttr(PragmaClangRelroSectionAttr::CreateImplicit(
+          Context, PragmaClangRelroSection.SectionName,
+          PragmaClangRelroSection.PragmaLocation,
+          AttributeCommonInfo::AS_Pragma));
   }
 
   if (auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
     for (auto *BD : DD->bindings()) {
       FinalizeDeclaration(BD);
     }
   }
 

clang/test/CodeGenCXX/clang-sections.cpp

 extern const int j;
 const int j = 4; // default - .rodata
 int k; // my_bss.2
 extern int zoo(int *x, int *y);
 int goo(void) {  // my_text.2
   static int lstat_h;  // my_bss.2
   return zoo(g, &lstat_h);
 }
-#pragma clang section rodata="my_rodata.2" data="my_data.2"
+#pragma clang section rodata="my_rodata.2" data="my_data.2" relro="my_relro.2"
 int l = 5; // my_data.2
 extern const int m;
 const int m = 6; // my_rodata.2
+
+typedef int (*fptr_t)(void);
+const fptr_t fptrs[2] = {&foo, &goo};
 #pragma clang section rodata="" data="" bss="" text=""
 int n; // default
 int o = 6; // default
 extern const int p;
 const int p = 7; // default
 int hoo(void) {
-  return b;
+  return b + fptrs[f]();
 }
 }
 //CHECK: @a = global i32 0, align 4 #0
 //CHECK: @b = global i32 1, align 4 #0
 //CHECK: @c = global [4 x i32] zeroinitializer, align 4 #0
 //CHECK: @d = global [5 x i16] zeroinitializer, align 2 #0
 //CHECK: @e = global [6 x i16] [i16 0, i16 0, i16 1, i16 0, i16 0, i16 0], align 2 #0
 //CHECK: @f = constant i32 2, align 4 #0
 
 //CHECK: @h = global i32 0, align 4 #1
 //CHECK: @i = global i32 0, align 4 #2
 //CHECK: @j = constant i32 4, align 4 #2
 //CHECK: @k = global i32 0, align 4 #2
 //CHECK: @_ZZ3gooE7lstat_h = internal global i32 0, align 4 #2
 //CHECK: @_ZL1g = internal global [2 x i32] zeroinitializer, align 4 #0
 
 //CHECK: @l = global i32 5, align 4 #3
 //CHECK: @m = constant i32 6, align 4 #3
 
 //CHECK: @n = global i32 0, align 4
 //CHECK: @o = global i32 6, align 4
 //CHECK: @p = constant i32 7, align 4
+//CHECK: @_ZL5fptrs = internal constant [2 x i32 ()*] [i32 ()* @foo, i32 ()* @goo], align 4 #3
 
-//CHECK: define i32 @foo() #4 {
-//CHECK: define i32 @goo() #5 {
-//CHECK: declare i32 @zoo(i32*, i32*) #6
-//CHECK: define i32 @hoo() #7 {
+//CHECK: define i32 @foo() #5 {
+//CHECK: define i32 @goo() #6 {
+//CHECK: declare i32 @zoo(i32*, i32*) #7
+//CHECK: define i32 @hoo() #8 {
 
 //CHECK: attributes #0 = { "bss-section"="my_bss.1" "data-section"="my_data.1" "rodata-section"="my_rodata.1" }
 //CHECK: attributes #1 = { "data-section"="my_data.1" "rodata-section"="my_rodata.1" }
 //CHECK: attributes #2 = { "bss-section"="my_bss.2" "rodata-section"="my_rodata.1" }
-//CHECK: attributes #3 = { "bss-section"="my_bss.2" "data-section"="my_data.2" "rodata-section"="my_rodata.2" }
-//CHECK: attributes #4 = { {{.*"implicit-section-name"="my_text.1".*}} }
-//CHECK: attributes #5 = { {{.*"implicit-section-name"="my_text.2".*}} }
-//CHECK-NOT: attributes #6 = { {{.*"implicit-section-name".*}} }
+//CHECK: attributes #3 = { "bss-section"="my_bss.2" "data-section"="my_data.2" "relro-section"="my_relro.2" "rodata-section"="my_rodata.2" }
+//CHECK: attributes #4 = { "relro-section"="my_relro.2" }
+//CHECK: attributes #5 = { {{.*"implicit-section-name"="my_text.1".*}} }
+//CHECK: attributes #6 = { {{.*"implicit-section-name"="my_text.2".*}} }
 //CHECK-NOT: attributes #7 = { {{.*"implicit-section-name".*}} }
+//CHECK-NOT: attributes #8 = { {{.*"implicit-section-name".*}} }

clang/test/Sema/pragma-clang-section.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s -triple arm-none-eabi
 #pragma clang section bss="mybss.1" data="mydata.1" rodata="myrodata.1" text="mytext.1"
 #pragma clang section bss="" data="" rodata="" text=""
 #pragma clang section
 
-#pragma clang section dss="mybss.2" // expected-error {{expected one of [bss|data|rodata|text] section kind in '#pragma clang section'}}
-#pragma clang section deta="mydata.2" // expected-error {{expected one of [bss|data|rodata|text] section kind in '#pragma clang section'}}
-#pragma clang section rodeta="rodata.2" // expected-error {{expected one of [bss|data|rodata|text] section kind in '#pragma clang section'}}
-#pragma clang section taxt="text.2" // expected-error {{expected one of [bss|data|rodata|text] section kind in '#pragma clang section'}}
+#pragma clang section dss="mybss.2" // expected-error {{expected one of [bss|data|rodata|text|relro] section kind in '#pragma clang section'}}
+#pragma clang section deta="mydata.2" // expected-error {{expected one of [bss|data|rodata|text|relro] section kind in '#pragma clang section'}}
+#pragma clang section rodeta="rodata.2" // expected-error {{expected one of [bss|data|rodata|text|relro] section kind in '#pragma clang section'}}
+#pragma clang section taxt="text.2" // expected-error {{expected one of [bss|data|rodata|text|relro] section kind in '#pragma clang section'}}
 
-#pragma clang section section bss="mybss.2"  // expected-error {{expected one of [bss|data|rodata|text] section kind in '#pragma clang section'}}
+#pragma clang section section bss="mybss.2"  // expected-error {{expected one of [bss|data|rodata|text|relro] section kind in '#pragma clang section'}}
 
 #pragma clang section bss "mybss.2"   // expected-error {{expected '=' following '#pragma clang section bss'}}
 #pragma clang section data "mydata.2"   // expected-error {{expected '=' following '#pragma clang section data'}}
 #pragma clang section rodata "myrodata.2"   // expected-error {{expected '=' following '#pragma clang section rodata'}}
-#pragma clang section bss="" data="" rodata="" text="" more //expected-error {{expected one of [bss|data|rodata|text] section kind in '#pragma clang section'}}
+#pragma clang section text "text.2"   // expected-error {{expected '=' following '#pragma clang section text'}}
+#pragma clang section relro "relro.2"   // expected-error {{expected '=' following '#pragma clang section relro'}}
+#pragma clang section bss="" data="" rodata="" text="" more //expected-error {{expected one of [bss|data|rodata|text|relro] section kind in '#pragma clang section'}}
 int a;

llvm/include/llvm/IR/GlobalVariable.h

public:
   void setAttributes(AttributeSet A) {
     Attrs = A;
   }
 
   /// Check if section name is present
   bool hasImplicitSection() const {
     return getAttributes().hasAttribute("bss-section") ||
            getAttributes().hasAttribute("data-section") ||
+           getAttributes().hasAttribute("relro-section") ||
            getAttributes().hasAttribute("rodata-section");
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalVariableVal;
   }
 };

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
   // and so section name is exactly as user specified and not uniqued.
   const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
   if (GV && GV->hasImplicitSection()) {
     auto Attrs = GV->getAttributes();
     if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
       SectionName = Attrs.getAttribute("bss-section").getValueAsString();
     } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
       SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
+    } else if (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) {
+      SectionName = Attrs.getAttribute("relro-section").getValueAsString();
     } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
       SectionName = Attrs.getAttribute("data-section").getValueAsString();
     }
   }
   const Function *F = dyn_cast<Function>(GO);
   if (F && F->hasFnAttribute("implicit-section-name")) {
     SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
   }

llvm/lib/Target/TargetLoweringObjectFile.cpp

MCSection *TargetLoweringObjectFile::SectionForGlobal(
   // Select section name.
   if (GO->hasSection())
     return getExplicitSectionGlobal(GO, Kind, TM);
 
   if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
     auto Attrs = GVar->getAttributes();
     if ((Attrs.hasAttribute("bss-section") && Kind.isBSS()) ||
         (Attrs.hasAttribute("data-section") && Kind.isData()) ||
+        (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) ||
         (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()))  {
        return getExplicitSectionGlobal(GO, Kind, TM);
     }
   }
 
   if (auto *F = dyn_cast<Function>(GO)) {
     if (F->hasFnAttribute("implicit-section-name"))
       return getExplicitSectionGlobal(GO, Kind, TM);

llvm/test/MC/ELF/section-relro.ll

+; Tests that data and relro are correctly placed in sections
+; specified by "#pragma clang section"
+; RUN: llc -filetype=obj -mtriple x86_64-unknown-linux %s -o - | llvm-readobj -S -t | FileCheck %s
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux"
+
+@funcs_relro = hidden constant [2 x i32 ()*] [i32 ()* bitcast (i32 (...)* @func1 to i32 ()*), i32 ()* bitcast (i32 (...)* @func2 to i32 ()*)], align 16 #0
+@var_data = hidden global i32 33, align 4 #0
+
+declare i32 @func1(...)
+declare i32 @func2(...)
+
+; Function Attrs: noinline nounwind optnone sspstrong uwtable
+define hidden i32 @foo(i32 %i) {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  %0 = load i32, i32* %i.addr, align 4
+  %idxprom = sext i32 %0 to i64
+  %arrayidx = getelementptr inbounds [2 x i32 ()*], [2 x i32 ()*]* @funcs_relro, i64 0, i64 %idxprom
+  %1 = load i32 ()*, i32 ()** %arrayidx, align 8
+  %call = call i32 %1()
+  %2 = load i32, i32* @var_data, align 4
+  %add = add nsw i32 %call, %2
+  ret i32 %add
+}
+
+attributes #0 = { "data-section"=".my_data" "relro-section"=".my_relro" "rodata-section"=".my_rodata" }
+
+; CHECK:  Section {
+; CHECK:    Index:
+; CHECK:    Name: .my_rodata
+; CHECK:    Type: SHT_PROGBITS (0x1)
+; CHECK:    Flags [ (0x2)
+; CHECK:      SHF_ALLOC (0x2)
+; CHECK:    ]
+; CHECK:    Size: 16
+; CHECK:  }
+; CHECK:  Section {
+; CHECK:    Index:
+; CHECK:    Name: .my_data
+; CHECK:    Type: SHT_PROGBITS (0x1)
+; CHECK:    Flags [ (0x3)
+; CHECK:      SHF_ALLOC (0x2)
+; CHECK:      SHF_WRITE (0x1)
+; CHECK:    ]
+; CHECK:    Size: 4
+; CHECK:  }
+; CHECK:   Symbol {
+; CHECK:    Name: funcs_relro
+; CHECK:    Value: 0x0
+; CHECK:    Size: 16
+; CHECK:    Binding: Global (0x1)
+; CHECK:    Type: Object (0x1)
+; CHECK:    Section: .my_rodata
+; CHECK:  }
+; CHECK:  Symbol {
+; CHECK:    Name: var_data
+; CHECK:    Value: 0x0
+; CHECK:    Size: 4
+; CHECK:    Binding: Global (0x1)
+; CHECK:    Type: Object (0x1)
+; CHECK:    Section: .my_data
+; CHECK:  }