Apply 0011-section_fixes.patch

dpaoliello · sivadeilra · commit dcfd96026978 · 2025-11-07T15:09:19.000-08:00
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
@@ -3668,6 +3668,9 @@ OPT_LIST(V)
     PSF_Execute = 0x4,
     PSF_Implicit = 0x8,
     PSF_ZeroInit = 0x10,
+    PSF_NoPage = 0x20,
+    PSF_Shared = 0x40,
+    PSF_Discard = 0x80,
     PSF_Invalid = 0x80000000U,
   };
 
diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
@@ -3238,6 +3238,14 @@ def Section : InheritableAttr {
   let Documentation = [SectionDocs];
 }
 
+def SectionFlags : InheritableAttr {
+  let Spellings = [];
+  let Args = [IntArgument<"Flags">];
+  let Subjects =
+      SubjectList<[ GlobalVar ], ErrorDiag>;
+  let Documentation = [SectionDocs];
+}
+
 // This is used for `__declspec(code_seg("segname"))`, but not for
 // `#pragma code_seg("segname")`.
 def CodeSeg : InheritableAttr {
@@ -3279,6 +3287,30 @@ def PragmaClangRelroSection : InheritableAttr {
   let Documentation = [InternalOnly];
 }
 
+def PragmaMSBSSSection : 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 = [InternalOnly];
+}
+
+def PragmaMSDataSection : 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 = [InternalOnly];
+}
+
+def PragmaMSConstSection : 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 = [InternalOnly];
+}
+
 def StrictFP : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   // Function uses strict floating point operations.
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1186,6 +1186,7 @@ def warn_cxx_ms_struct :
 def err_pragma_pack_identifer_not_supported : Error<
   "specifying an identifier within `#pragma pack` is not supported on this target">;
 def err_section_conflict : Error<"%0 causes a section type conflict with %1">;
+def err_section_unknown : Error<"%0 assigned to unknown section %1">;
 def warn_section_msvc_compat : Warning<"`#pragma const_seg` for section %1 will"
   " not apply to %0 due to the presence of a %select{mutable field||non-trivial constructor|non-trivial destructor}2">,
   InGroup<IncompatibleMSPragmaSection>;
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
@@ -2020,10 +2020,10 @@ class Sema final : public SemaBase {
   };
   SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack;
   // Segment #pragmas.
-  PragmaStack<StringLiteral *> DataSegStack;
-  PragmaStack<StringLiteral *> BSSSegStack;
-  PragmaStack<StringLiteral *> ConstSegStack;
-  PragmaStack<StringLiteral *> CodeSegStack;
+  PragmaStack<std::string> DataSegStack;
+  PragmaStack<std::string> BSSSegStack;
+  PragmaStack<std::string> ConstSegStack;
+  PragmaStack<std::string> CodeSegStack;
 
   // #pragma strict_gs_check.
   PragmaStack<bool> StrictGuardStackCheckStack;
@@ -2061,7 +2061,7 @@ class Sema final : public SemaBase {
   };
 
   /// Last section used with #pragma init_seg.
-  StringLiteral *CurInitSeg;
+  std::string CurInitSeg;
   SourceLocation CurInitSegLoc;
 
   /// Sections used with #pragma alloc_text.
@@ -2221,6 +2221,7 @@ class Sema final : public SemaBase {
                     NamedDecl *TheDecl);
   bool UnifySection(StringRef SectionName, int SectionFlags,
                     SourceLocation PragmaSectionLocation);
+  void AttachSectionFlags(VarDecl *VarDecl, StringRef SectionName);
 
   /// Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg.
   void ActOnPragmaMSSeg(SourceLocation PragmaLocation,
diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h
@@ -742,6 +742,15 @@ enum ASTRecordTypes {
   UPDATE_MODULE_LOCAL_VISIBLE = 76,
 
   UPDATE_TU_LOCAL_VISIBLE = 77,
+
+  // Record for for current init section
+  CURRENT_INIT_SECTION = 78,
+
+  // Record code for the SectionInfos table that records the known sections
+  SECTION_INFOS = 79,
+
+  // Record code for the pragma segment stacks
+  SEGMENT_PRAGMA_OPTIONS = 80,
 };
 
 /// Record types used within a source manager block.
diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h
@@ -1029,6 +1029,37 @@ class ASTReader
   llvm::SmallVector<PragmaAlignPackStackEntry, 2> PragmaAlignPackStack;
   llvm::SmallVector<std::string, 2> PragmaAlignPackStrings;
 
+  // The pragma init_seg() state.
+  std::string CurInitSeg = "";
+  SourceLocation CurInitSegLoc;
+
+  // The section info state
+  struct SectionInfo {
+    std::string SectionName;
+    SourceLocation PragmaSectionLocation;
+    int SectionFlags;
+  };
+  llvm::SmallVector<SectionInfo, 2> SectionInfos;
+
+  struct PragmaSegmentStackEntry {
+    std::string Value;
+    SourceLocation Location;
+    SourceLocation PushLocation;
+    StringRef SlotLabel;
+  };
+
+  struct PragmaSegmentStackState {
+    std::optional<std::string> PragmaCurrentValue;
+    SourceLocation PragmaCurrentLocation;
+    llvm::SmallVector<PragmaSegmentStackEntry, 2> PragmaStack;
+    llvm::SmallVector<std::string, 2> PragmaStrings;
+  };
+
+  PragmaSegmentStackState PragmaDataSegmentStackState;
+  PragmaSegmentStackState PragmaBSSSegmentStackState;
+  PragmaSegmentStackState PragmaConstSegmentStackState;
+  PragmaSegmentStackState PragmaCodeSegmentStackState;
+
   /// The OpenCL extension settings.
   OpenCLOptions OpenCLExtensions;
 
@@ -1942,6 +1973,8 @@ class ASTReader
   /// Initializes the ASTContext
   void InitializeContext();
 
+  void UpdateSemaPragmaSegment(PragmaSegmentStackState &StackState, Sema::PragmaStack<std::string> &PragmaStack);
+
   /// Update the state of Sema after loading some additional modules.
   void UpdateSema();
 
diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h
@@ -634,6 +634,10 @@ class ASTWriter : public ASTDeserializationListener,
   void WriteMSPointersToMembersPragmaOptions(Sema &SemaRef);
   void WritePackPragmaOptions(Sema &SemaRef);
   void WriteFloatControlPragmaOptions(Sema &SemaRef);
+  void WriteInitSection(Sema &SemaRef);
+  void WriteSectionInfos(Sema &SemaRef);
+  void WriteSegmentStack(Sema::PragmaStack<std::string> &SegmentStack, StringRef SegmentName);
+  void WriteSegmentStacks(Sema &SemaRef);
   void WriteDeclsWithEffectsToVerify(Sema &SemaRef);
   void WriteModuleFileExtension(Sema &SemaRef,
                                 ModuleFileExtensionWriter &Writer);
diff --git a/clang/lib/CodeGen/CGDecl.cpp b/clang/lib/CodeGen/CGDecl.cpp
@@ -449,6 +449,13 @@ void CodeGenFunction::EmitStaticVarDecl(const VarDecl &D,
   if (auto *SA = D.getAttr<PragmaClangRelroSectionAttr>())
     var->addAttribute("relro-section", SA->getName());
 
+  if (auto *SA = D.getAttr<PragmaMSBSSSectionAttr>())
+    var->addAttribute("bss-section", SA->getName());
+  if (auto *SA = D.getAttr<PragmaMSDataSectionAttr>())
+    var->addAttribute("data-section", SA->getName());
+  if (auto *SA = D.getAttr<PragmaMSConstSectionAttr>())
+    var->addAttribute("rodata-section", SA->getName());
+
   if (const SectionAttr *SA = D.getAttr<SectionAttr>())
     var->setSection(SA->getName());
 
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -2934,6 +2934,13 @@ void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
         GV->addAttribute("rodata-section", SA->getName());
       if (auto *SA = D->getAttr<PragmaClangRelroSectionAttr>())
         GV->addAttribute("relro-section", SA->getName());
+
+      if (auto *SA = D->getAttr<PragmaMSBSSSectionAttr>())
+        GV->addAttribute("bss-section", SA->getName());
+      if (auto *SA = D->getAttr<PragmaMSDataSectionAttr>())
+        GV->addAttribute("data-section", SA->getName());
+      if (auto *SA = D->getAttr<PragmaMSConstSectionAttr>())
+        GV->addAttribute("rodata-section", SA->getName());
     }
 
     if (auto *F = dyn_cast<llvm::Function>(GO)) {
@@ -5900,11 +5907,9 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
                    D->getType().isConstantStorage(getContext(), true, true)));
 
   // If it is in a read-only section, mark it 'constant'.
-  if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
-    const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
-    if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
+  if (const SectionFlagsAttr *SFA = D->getAttr<SectionFlagsAttr>())
+    if ((SFA->getFlags() & ASTContext::PSF_Write) == 0)
       GV->setConstant(true);
-  }
 
   CharUnits AlignVal = getContext().getDeclAlign(D);
   // Check for alignment specifed in an 'omp allocate' directive.
diff --git a/clang/lib/Parse/ParsePragma.cpp b/clang/lib/Parse/ParsePragma.cpp
@@ -1097,10 +1097,10 @@ bool Parser::HandlePragmaMSSection(StringRef PragmaName,
       .Case("read", ASTContext::PSF_Read)
       .Case("write", ASTContext::PSF_Write)
       .Case("execute", ASTContext::PSF_Execute)
-      .Case("shared", ASTContext::PSF_Invalid)
-      .Case("nopage", ASTContext::PSF_Invalid)
+      .Case("shared", ASTContext::PSF_Shared)
+      .Case("nopage", ASTContext::PSF_NoPage)
       .Case("nocache", ASTContext::PSF_Invalid)
-      .Case("discard", ASTContext::PSF_Invalid)
+      .Case("discard", ASTContext::PSF_Discard)
       .Case("remove", ASTContext::PSF_Invalid)
       .Default(ASTContext::PSF_None);
     if (Flag == ASTContext::PSF_None || Flag == ASTContext::PSF_Invalid) {
diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
@@ -311,9 +311,9 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
           LangOpts.getMSPointerToMemberRepresentationMethod()),
       MSStructPragmaOn(false), VtorDispStack(LangOpts.getVtorDispMode()),
       AlignPackStack(AlignPackInfo(getLangOpts().XLPragmaPack)),
-      DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
-      CodeSegStack(nullptr), StrictGuardStackCheckStack(false),
-      FpPragmaStack(FPOptionsOverride()), CurInitSeg(nullptr),
+      DataSegStack(""), BSSSegStack(""), ConstSegStack(""),
+      CodeSegStack(""), StrictGuardStackCheckStack(false),
+      FpPragmaStack(FPOptionsOverride()), CurInitSeg(""),
       VisContext(nullptr), PragmaAttributeCurrentTargetDecl(nullptr),
       StdCoroutineTraitsCache(nullptr), IdResolver(pp),
       OriginalLexicalContext(nullptr), StdInitializerList(nullptr),
diff --git a/clang/lib/Sema/SemaAttr.cpp b/clang/lib/Sema/SemaAttr.cpp
@@ -843,18 +843,38 @@ bool Sema::UnifySection(StringRef SectionName,
   return false;
 }
 
-/// Called on well formed \#pragma bss_seg().
+void Sema::AttachSectionFlags(VarDecl *VD, StringRef SectionName) {
+  auto SectionIt = Context.SectionInfos.find(SectionName);
+  if (SectionIt != Context.SectionInfos.end()) {
+    const auto &Section = SectionIt->second;
+
+    VD->addAttr(SectionFlagsAttr::CreateImplicit(Context, Section.SectionFlags));
+  } else {
+    Diag(VD->getLocation(), diag::err_section_unknown) << VD->getName() << SectionName;
+  }
+}
+
+/// Called on well formed \#pragma data_seg|bss_seg|const_seg|code_seg
 void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
                             PragmaMsStackAction Action,
                             llvm::StringRef StackSlotLabel,
                             StringLiteral *SegmentName,
                             llvm::StringRef PragmaName) {
-  PragmaStack<StringLiteral *> *Stack =
-    llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
+  PragmaStack<std::string> *Stack =
+      llvm::StringSwitch<PragmaStack<std::string> *>(PragmaName)
         .Case("data_seg", &DataSegStack)
         .Case("bss_seg", &BSSSegStack)
         .Case("const_seg", &ConstSegStack)
         .Case("code_seg", &CodeSegStack);
+
+  int SectionFlags = ASTContext::PSF_Read;
+  if (Stack == &DataSegStack)
+    SectionFlags |= ASTContext::PSF_Write;
+  else if (Stack == &BSSSegStack)
+    SectionFlags |= ASTContext::PSF_Write | ASTContext::PSF_ZeroInit;
+  else if (Stack == &CodeSegStack)
+    SectionFlags |= ASTContext::PSF_Execute;
+
   if (Action & PSK_Pop && Stack->Stack.empty())
     Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
         << "stack empty";
@@ -867,7 +887,14 @@ void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
       Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;
   }
 
-  Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
+  if (Action & PSK_Set && SegmentName)
+    UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
+
+  if (SegmentName) {
+    Stack->Act(PragmaLocation, Action, StackSlotLabel, std::string(SegmentName->getString()));
+  } else {
+    Stack->Act(PragmaLocation, Action, StackSlotLabel, std::string(""));
+  }
 }
 
 /// Called on well formed \#pragma strict_gs_check().
@@ -881,19 +908,22 @@ void Sema::ActOnPragmaMSStrictGuardStackCheck(SourceLocation PragmaLocation,
   StrictGuardStackCheckStack.Act(PragmaLocation, Action, StringRef(), Value);
 }
 
-/// Called on well formed \#pragma bss_seg().
+/// Called on well formed \#pragma section
 void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
                                 int SectionFlags, StringLiteral *SegmentName) {
   UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
 }
 
+/// Called on well formed \#pragma init_seg
 void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
                                 StringLiteral *SegmentName) {
   // There's no stack to maintain, so we just have a current section.  When we
   // see the default section, reset our current section back to null so we stop
   // tacking on unnecessary attributes.
-  CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
+  CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? "" : SegmentName->getString();
   CurInitSegLoc = PragmaLocation;
+
+  // Should call UnifySection but with what flags?
 }
 
 void Sema::ActOnPragmaMSAllocText(
@@ -905,6 +935,8 @@ void Sema::ActOnPragmaMSAllocText(
     return;
   }
 
+  UnifySection(Section, ASTContext::PSF_Read | ASTContext::PSF_Execute, PragmaLocation);
+
   for (auto &Function : Functions) {
     IdentifierInfo *II;
     SourceLocation Loc;
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
diff --git a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp
diff --git a/llvm/lib/Target/TargetLoweringObjectFile.cpp b/llvm/lib/Target/TargetLoweringObjectFile.cpp
