Refactor to avoid link problems

Author: JonPsson1

clang/include/clang/AST/ASTContext.h

@@ -2405,13 +2405,19 @@ class ASTContext : public RefCountedBase<ASTContext> {
   unsigned getTargetDefaultAlignForAttributeAligned() const;
 
   /// Return the alignment in bits that should be given to a
-  /// global variable with type \p T.
+  /// global variable with type \p T. If \p VD is non-null it will be
+  /// considered specifically for the query.
   unsigned getAlignOfGlobalVar(QualType T, const VarDecl *VD) const;
 
   /// Return the alignment in characters that should be given to a
-  /// global variable with type \p T.
+  /// global variable with type \p T. If \p VD is non-null it will be
+  /// considered specifically for the query.
   CharUnits getAlignOfGlobalVarInChars(QualType T, const VarDecl *VD) const;
 
+  /// Return the minimum alignement as specified by the target. If \p VD is
+  /// non-null it may be used to identify external or weak variables.
+  unsigned getMinGlobalAlignOfVar(uint64_t Size, const VarDecl *VD) const;
+
   /// Return a conservative estimate of the alignment of the specified
   /// decl \p D.
   ///

clang/include/clang/Basic/TargetInfo.h

@@ -50,7 +50,6 @@ class DiagnosticsEngine;
 class LangOptions;
 class CodeGenOptions;
 class MacroBuilder;
-class VarDecl;
 
 /// Contains information gathered from parsing the contents of TargetAttr.
 struct ParsedTargetAttr {
@@ -705,9 +704,10 @@ class TargetInfo : public TransferrableTargetInfo,
   }
 
   /// getMinGlobalAlign - Return the minimum alignment of a global variable,
-  /// unless its alignment is explicitly reduced via attributes. If \param VD
-  /// is non-null, it may be used to examine the specific variable's attributes.
-  virtual unsigned getMinGlobalAlign(uint64_t Size, const VarDecl *VD) const {
+  /// unless its alignment is explicitly reduced via attributes. If \param
+  /// HasNonWeakDef is true, this concerns a VarDecl which has a definition
+  /// in current translation unit and that is not weak.
+  virtual unsigned getMinGlobalAlign(uint64_t Size, bool HasNonWeakDef) const {
     return MinGlobalAlign;
   }
 

clang/lib/AST/ASTContext.cpp

@@ -1688,8 +1688,7 @@ CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
       if (VD->hasGlobalStorage() && !ForAlignof) {
         uint64_t TypeSize =
             !BaseT->isIncompleteType() ? getTypeSize(T.getTypePtr()) : 0;
-        Align =
-            std::max(Align, getTargetInfo().getMinGlobalAlign(TypeSize, VD));
+        Align = std::max(Align, getMinGlobalAlignOfVar(TypeSize, VD));
       }
 
     // Fields can be subject to extra alignment constraints, like if
@@ -2514,7 +2513,7 @@ unsigned ASTContext::getTargetDefaultAlignForAttributeAligned() const {
 unsigned ASTContext::getAlignOfGlobalVar(QualType T, const VarDecl *VD) const {
   uint64_t TypeSize = getTypeSize(T.getTypePtr());
   return std::max(getPreferredTypeAlign(T),
-                  getTargetInfo().getMinGlobalAlign(TypeSize, VD));
+                  getMinGlobalAlignOfVar(TypeSize, VD));
 }
 
 /// getAlignOfGlobalVarInChars - Return the alignment in characters that
@@ -2524,6 +2523,14 @@ CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T,
   return toCharUnitsFromBits(getAlignOfGlobalVar(T, VD));
 }
 
+unsigned ASTContext::getMinGlobalAlignOfVar(uint64_t Size,
+                                            const VarDecl *VD) const {
+  // Make the default handling as that of a non-weak definition in the
+  // current translation unit.
+  bool HasNonWeakDef = !VD || (VD->hasDefinition() && !VD->isWeak());
+  return getTargetInfo().getMinGlobalAlign(Size, HasNonWeakDef);
+}
+
 CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const {
   CharUnits Offset = CharUnits::Zero();
   const ASTRecordLayout *Layout = &getASTRecordLayout(RD);

clang/lib/Basic/Targets/AArch64.cpp

@@ -1518,8 +1518,9 @@ MicrosoftARM64TargetInfo::getCallingConvKind(bool ClangABICompat4) const {
 }
 
 unsigned MicrosoftARM64TargetInfo::getMinGlobalAlign(uint64_t TypeSize,
-                                                     const VarDecl *VD) const {
-  unsigned Align = WindowsARM64TargetInfo::getMinGlobalAlign(TypeSize, VD);
+                                                     bool HasNonWeakDef) const {
+  unsigned Align =
+      WindowsARM64TargetInfo::getMinGlobalAlign(TypeSize, HasNonWeakDef);
 
   // MSVC does size based alignment for arm64 based on alignment section in
   // below document, replicate that to keep alignment consistent with object

clang/lib/Basic/Targets/AArch64.h

@@ -237,7 +237,7 @@ class LLVM_LIBRARY_VISIBILITY MicrosoftARM64TargetInfo
   getCallingConvKind(bool ClangABICompat4) const override;
 
   unsigned getMinGlobalAlign(uint64_t TypeSize,
-                             const VarDecl *VD) const override;
+                             bool HasNonWeakDef) const override;
 };
 
 // ARM64 MinGW target

clang/lib/Basic/Targets/CSKY.cpp

@@ -309,7 +309,7 @@ bool CSKYTargetInfo::validateAsmConstraint(
 }
 
 unsigned CSKYTargetInfo::getMinGlobalAlign(uint64_t Size,
-                                           const VarDecl *VD) const {
+                                           bool HasNonWeakDef) const {
   if (Size >= 32)
     return 32;
   return 0;

clang/lib/Basic/Targets/CSKY.h

@@ -71,7 +71,7 @@ class LLVM_LIBRARY_VISIBILITY CSKYTargetInfo : public TargetInfo {
 
   bool isValidCPUName(StringRef Name) const override;
 
-  unsigned getMinGlobalAlign(uint64_t, const VarDecl *) const override;
+  unsigned getMinGlobalAlign(uint64_t, bool HasNonWeakDef) const override;
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 

clang/lib/Basic/Targets/NVPTX.cpp

@@ -116,7 +116,7 @@ NVPTXTargetInfo::NVPTXTargetInfo(const llvm::Triple &Triple,
   LongLongWidth = HostTarget->getLongLongWidth();
   LongLongAlign = HostTarget->getLongLongAlign();
   MinGlobalAlign = HostTarget->getMinGlobalAlign(/* TypeSize = */ 0,
-                                                 /* VD = */ nullptr);
+                                                 /* HasNonWeakDef = */ true);
   NewAlign = HostTarget->getNewAlign();
   DefaultAlignForAttributeAligned =
       HostTarget->getDefaultAlignForAttributeAligned();

clang/lib/Basic/Targets/SPIR.h

@@ -125,8 +125,9 @@ class LLVM_LIBRARY_VISIBILITY BaseSPIRTargetInfo : public TargetInfo {
       LongAlign = HostTarget->getLongAlign();
       LongLongWidth = HostTarget->getLongLongWidth();
       LongLongAlign = HostTarget->getLongLongAlign();
-      MinGlobalAlign = HostTarget->getMinGlobalAlign(/* TypeSize = */ 0,
-                                                     /* VD = */ nullptr);
+      MinGlobalAlign =
+          HostTarget->getMinGlobalAlign(/* TypeSize = */ 0,
+                                        /* HasNonWeakDef = */ true);
       NewAlign = HostTarget->getNewAlign();
       DefaultAlignForAttributeAligned =
           HostTarget->getDefaultAlignForAttributeAligned();

clang/lib/Basic/Targets/SystemZ.cpp

@@ -140,10 +140,10 @@ bool SystemZTargetInfo::hasFeature(StringRef Feature) const {
 }
 
 unsigned SystemZTargetInfo::getMinGlobalAlign(uint64_t Size,
-                                              const VarDecl *VD) const {
+                                              bool HasNonWeakDef) const {
   // Don't enforce the minimum alignment on an external or weak symbol if
   // -munaligned-symbols is passed.
-  if (UnalignedSymbols && VD && (!VD->hasDefinition() || VD->isWeak()))
+  if (UnalignedSymbols && !HasNonWeakDef)
     return 0;
 
   return MinGlobalAlign;