Apply 0023-dynfixup-aslr.patch

dpaoliello · sivadeilra · commit a8c2b7d2834f · 2025-11-07T15:09:36.000-08:00
diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
@@ -5255,3 +5255,10 @@ def NonString : InheritableAttr {
   let Subjects = SubjectList<[Var, Field]>;
   let Documentation = [NonStringDocs];
 }
+
+def DynamicFixup : InheritableAttr {
+  let Spellings = [Declspec<"dynfixup">];
+  let Subjects = SubjectList<[ExternalGlobalVar]>;
+  let LangOpts = [MicrosoftExt];
+  let Documentation = [Undocumented];
+}
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -5310,6 +5310,14 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty,
         isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
       GV->setSection(".cp.rodata");
 
+    // Propagate MSVC dynamic fixup attribute for globals for further handling
+    // in target(s).
+    if (getTriple().isWindowsMSVCEnvironment() &&
+        D->getLanguageLinkage() == CLanguageLinkage &&
+        isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
+      if (const DynamicFixupAttr *DA = D->getAttr<DynamicFixupAttr>())
+        GV->addAttribute("msvc_dynfixup");
+
     // Handle code model attribute
     if (const auto *CMA = D->getAttr<CodeModelAttr>())
       GV->setCodeModel(CMA->getModel());
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -6961,6 +6961,11 @@ static void handleVTablePointerAuthentication(Sema &S, Decl *D,
       CustomDiscriminationValue));
 }
 
+static void handleDynamicFixup(Sema &S, Decl *D,
+                               const ParsedAttr &AL) {
+  D->addAttr(::new ( S.Context) DynamicFixupAttr(S.Context, AL));
+}
+
 //===----------------------------------------------------------------------===//
 // Top Level Sema Entry Points
 //===----------------------------------------------------------------------===//
@@ -7885,6 +7890,11 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
   case ParsedAttr::AT_VTablePointerAuthentication:
     handleVTablePointerAuthentication(S, D, AL);
     break;
+
+  case ParsedAttr::AT_DynamicFixup:
+    handleDynamicFixup(S, D, AL);
+    break;
+
   }
 }
 
diff --git a/llvm/include/llvm/MC/MCExpr.h b/llvm/include/llvm/MC/MCExpr.h
@@ -196,6 +196,7 @@ class MCSymbolRefExpr : public MCExpr {
   // a cleaner approach.
   enum VariantKind : uint16_t {
     VK_COFF_IMGREL32 = 3, // symbol@imgrel (image-relative)
+    VK_COFF_DYNFIXUP, // Absolute relocation for external tooling
 
     FirstTargetSpecifier,
   };
diff --git a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
@@ -3563,6 +3563,15 @@ const MCExpr *AArch64AsmPrinter::lowerConstant(const Constant *CV,
                                                const Constant *BaseCV,
                                                uint64_t Offset) {
   if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
+
+    // Check for dynamic fixup in the constant pool and propagate to the symbol
+    // reference
+    if (const auto *GVar = dyn_cast<llvm::GlobalVariable>(GV)) {
+        if (GVar->hasAttribute("msvc_dynfixup"))
+          return MCSymbolRefExpr::create(MCInstLowering.GetGlobalValueSymbol(GV, 0),
+                                         MCSymbolRefExpr::VK_COFF_DYNFIXUP,
+                                         OutContext);
+    }
     return MCSymbolRefExpr::create(MCInstLowering.GetGlobalValueSymbol(GV, 0),
                                    OutContext);
   }
diff --git a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
@@ -9890,6 +9890,17 @@ SDValue AArch64TargetLowering::LowerGlobalAddress(SDValue Op,
   }
 
   SDValue Result;
+  SDLoc DL(GN);
+  EVT PtrVT = getPointerTy(DAG.getDataLayout());
+
+  // Dynamic fixups require an absolute relocation, so lower to a load from the
+  // constant pool where this relocation can be applied.
+  if ((OpFlags & AArch64II::MO_DYNFIXUP) != 0) {
+    Result = DAG.getTargetConstantPool(GV, PtrVT, Align(8));
+    Result = DAG.getNode(AArch64ISD::LOADgot, DL, PtrVT, Result);
+    return Result;
+  }
+
   if (getTargetMachine().getCodeModel() == CodeModel::Large &&
       !getTargetMachine().isPositionIndependent()) {
     Result = getAddrLarge(GN, DAG, OpFlags);
@@ -9898,8 +9909,6 @@ SDValue AArch64TargetLowering::LowerGlobalAddress(SDValue Op,
   } else {
     Result = getAddr(GN, DAG, OpFlags);
   }
-  EVT PtrVT = getPointerTy(DAG.getDataLayout());
-  SDLoc DL(GN);
   if (OpFlags & (AArch64II::MO_DLLIMPORT | AArch64II::MO_COFFSTUB))
     Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result,
                          MachinePointerInfo::getGOT(DAG.getMachineFunction()));
diff --git a/llvm/lib/Target/AArch64/AArch64Subtarget.cpp b/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
@@ -24,6 +24,7 @@
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineScheduler.h"
 #include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/GlobalVariable.h"
 #include "llvm/Support/SipHash.h"
 #include "llvm/TargetParser/AArch64TargetParser.h"
 
@@ -464,6 +465,14 @@ AArch64Subtarget::ClassifyGlobalReference(const GlobalValue *GV,
   if (TM.getCodeModel() == CodeModel::Large && isTargetMachO())
     return AArch64II::MO_GOT;
 
+  // MSVC Dynamic fixup requires a an absolute relocation.  Load from constant
+  // pool and apply that relocation there.
+  if (const auto *GVar = dyn_cast<llvm::GlobalVariable>(GV)) {
+    if (GVar->hasAttribute("msvc_dynfixup")) {
+      return AArch64II::MO_DYNFIXUP;
+    }
+  }
+
   // All globals dynamically protected by MTE must have their address tags
   // synthesized. This is done by having the loader stash the tag in the GOT
   // entry. Force all tagged globals (even ones with internal linkage) through
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp
@@ -33,6 +33,7 @@ static cl::opt<AsmWriterVariantTy> AsmWriterVariant(
 
 const MCAsmInfo::AtSpecifier COFFAtSpecifiers[] = {
     {MCSymbolRefExpr::VK_COFF_IMGREL32, "IMGREL"},
+    {MCSymbolRefExpr::VK_COFF_DYNFIXUP, "DYNFIXUP"},
     {AArch64::S_MACHO_PAGEOFF, "PAGEOFF"},
 };
 
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp
@@ -47,6 +47,7 @@ class AArch64WinCOFFObjectWriter : public MCWinCOFFObjectTargetWriter {
 unsigned AArch64WinCOFFObjectWriter::getRelocType(
     MCContext &Ctx, const MCValue &Target, const MCFixup &Fixup,
     bool IsCrossSection, const MCAsmBackend &MAB) const {
+
   unsigned FixupKind = Fixup.getKind();
   bool PCRel = Fixup.isPCRel();
   if (IsCrossSection) {
@@ -105,7 +106,10 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType(
     }
 
   case FK_Data_8:
-    return COFF::IMAGE_REL_ARM64_ADDR64;
+    if (Spec == MCSymbolRefExpr::VK_COFF_DYNFIXUP)
+      return COFF::IMAGE_REL_ARM64_ABSOLUTE;
+    else
+      return COFF::IMAGE_REL_ARM64_ADDR64;
 
   case FK_SecRel_2:
     return COFF::IMAGE_REL_ARM64_SECTION;
diff --git a/llvm/lib/Target/AArch64/Utils/AArch64BaseInfo.h b/llvm/lib/Target/AArch64/Utils/AArch64BaseInfo.h
@@ -883,6 +883,13 @@ enum TOF {
   /// uses "__imp_aux".  For other symbols, this means it uses the mangled
   /// ("#" prefix for C) name.
   MO_ARM64EC_CALLMANGLE = 0x800,
+
+  /// MO_DYNFIXUP - This flag indicates that this symbol will be dynamically
+  // fixed up -- first by the linker, and then potentially at runtime.
+  // Reference it from the literal pool with an ABS relocation
+  // N.B. Never stored so does not exceed 12 bits associated with target flags
+  MO_DYNFIXUP = 0x1000,
+
 };
 } // end namespace AArch64II
 
diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86MCAsmInfo.cpp b/llvm/lib/Target/X86/MCTargetDesc/X86MCAsmInfo.cpp
@@ -49,6 +49,7 @@ const MCAsmInfo::AtSpecifier atSpecifiers[] = {
     {X86::S_GOTTPOFF, "GOTTPOFF"},
     {X86::S_INDNTPOFF, "INDNTPOFF"},
     {MCSymbolRefExpr::VK_COFF_IMGREL32, "IMGREL"},
+    {MCSymbolRefExpr::VK_COFF_DYNFIXUP, "DYNFIXUP"},
     {X86::S_NTPOFF, "NTPOFF"},
     {X86::S_PCREL, "PCREL"},
     {X86::S_PLT, "PLT"},
diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86MCAsmInfo.h b/llvm/lib/Target/X86/MCTargetDesc/X86MCAsmInfo.h
@@ -97,6 +97,7 @@ enum {
   S_TLVPPAGE,
   S_TLVPPAGEOFF,
   S_TPOFF,
+  S_COFF_DYNFIXUP, // Absolute relocation for external tooling
 };
 } // namespace X86
 } // namespace llvm
diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp b/llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp
@@ -86,6 +86,8 @@ unsigned X86WinCOFFObjectWriter::getRelocType(MCContext &Ctx,
         return COFF::IMAGE_REL_AMD64_SECREL;
       return COFF::IMAGE_REL_AMD64_ADDR32;
     case FK_Data_8:
+      if (Spec == MCSymbolRefExpr::VK_COFF_DYNFIXUP)
+        return COFF::IMAGE_REL_AMD64_ABSOLUTE;
       return COFF::IMAGE_REL_AMD64_ADDR64;
     case FK_SecRel_2:
       return COFF::IMAGE_REL_AMD64_SECTION;
diff --git a/llvm/lib/Target/X86/X86AsmPrinter.cpp b/llvm/lib/Target/X86/X86AsmPrinter.cpp
@@ -1104,6 +1104,21 @@ void X86AsmPrinter::emitEndOfAsmFile(Module &M) {
   }
 }
 
+const MCExpr *X86AsmPrinter::lowerConstant(const Constant *CV,
+                                      const Constant *BaseCV,
+                                      uint64_t Offset) {
+  if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
+    // Check for dynamic fixup in the constant pool and propagate to the symbol
+    // reference
+    if (const auto *GVar = dyn_cast<llvm::GlobalVariable>(GV)) {
+        if (GVar->hasAttribute("msvc_dynfixup"))
+          return MCSymbolRefExpr::create(getSymbol(GV), MCSymbolRefExpr::VK_COFF_DYNFIXUP, OutContext);
+    }
+  }
+
+  return AsmPrinter::lowerConstant(CV, BaseCV, Offset);
+}
+
 char X86AsmPrinter::ID = 0;
 
 INITIALIZE_PASS(X86AsmPrinter, "x86-asm-printer", "X86 Assembly Printer", false,
diff --git a/llvm/lib/Target/X86/X86AsmPrinter.h b/llvm/lib/Target/X86/X86AsmPrinter.h
@@ -186,6 +186,10 @@ class LLVM_LIBRARY_VISIBILITY X86AsmPrinter : public AsmPrinter {
   }
 
   bool runOnMachineFunction(MachineFunction &MF) override;
+  const MCExpr *lowerConstant(const Constant *CV,
+                                      const Constant *BaseCV = nullptr,
+                                      uint64_t Offset = 0) override;
+
   void emitFunctionBodyStart() override;
   void emitFunctionBodyEnd() override;
   void emitKCFITypeId(const MachineFunction &MF) override;
diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp b/llvm/lib/Target/X86/X86ISelLowering.cpp
@@ -19304,7 +19304,19 @@ SDValue X86TargetLowering::LowerGlobalOrExternal(SDValue Op, SelectionDAG &DAG,
         X86::isOffsetSuitableForCodeModel(Offset, M, true)) {
       std::swap(GlobalOffset, Offset);
     }
-    Result = DAG.getTargetGlobalAddress(GV, dl, PtrVT, GlobalOffset, OpFlags);
+    bool fromConstantPool = false;
+    if (const auto *GVar = dyn_cast<llvm::GlobalVariable>(GV)) {
+      if (GVar->hasAttribute("msvc_dynfixup")) {
+        fromConstantPool = true;
+      }
+    }
+    if (!fromConstantPool) {
+      Result = DAG.getTargetGlobalAddress(GV, dl, PtrVT, GlobalOffset, OpFlags);
+    } else {
+      // XXX offset issues?
+      Result = DAG.getTargetConstantPool(GV, PtrVT, Align(8));
+      NeedsLoad = true;
+    }
   } else {
     // If this is not a global address, this must be an external symbol.
     Result = DAG.getTargetExternalSymbol(ExternalSym, PtrVT, OpFlags);
