[Alignment][NFC] Remove deprecated GlobalObject::getAlignment

llvm/include/llvm/IR/GlobalObject.h

 private:
   static const unsigned AlignmentBits = LastAlignmentBit + 1;
   static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
   static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
 
 public:
   GlobalObject(const GlobalObject &) = delete;
 
-  /// FIXME: Remove this function once transition to Align is over.
-  uint64_t getAlignment() const {
-    MaybeAlign Align = getAlign();
-    return Align ? Align->value() : 0;
-  }
-
   /// Returns the alignment of the given variable or function.
   ///
   /// Note that for functions this is the alignment of the code, not the
   /// alignment of a function pointer.
   MaybeAlign getAlign() const {
     unsigned Data = getGlobalValueSubClassData();
     unsigned AlignmentData = Data & AlignmentMask;
     return decodeMaybeAlign(AlignmentData);

llvm/lib/IR/Globals.cpp

 }
 
 void GlobalObject::setAlignment(MaybeAlign Align) {
   assert((!Align || *Align <= MaximumAlignment) &&
          "Alignment is greater than MaximumAlignment!");
   unsigned AlignmentData = encode(Align);
   unsigned OldData = getGlobalValueSubClassData();
   setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
-  assert(MaybeAlign(getAlignment()) == Align &&
-         "Alignment representation error!");
+  assert(getAlign() == Align && "Alignment representation error!");
 }
 
 void GlobalObject::copyAttributesFrom(const GlobalObject *Src) {
   GlobalValue::copyAttributesFrom(Src);
   setAlignment(Src->getAlign());
   setSection(Src->getSection());
 }
 

llvm/lib/Linker/LinkModules.cpp

if (DGV && !GV.hasLocalLinkage() && !GV.hasAppendingLinkage()) {
     auto *SGVar = dyn_cast<GlobalVariable>(&GV);
     if (DGVar && SGVar) {
       if (DGVar->isDeclaration() && SGVar->isDeclaration() &&
           (!DGVar->isConstant() || !SGVar->isConstant())) {
         DGVar->setConstant(false);
         SGVar->setConstant(false);
       }
       if (DGVar->hasCommonLinkage() && SGVar->hasCommonLinkage()) {
-        MaybeAlign Align(
-            std::max(DGVar->getAlignment(), SGVar->getAlignment()));
+        MaybeAlign DAlign = DGVar->getAlign();
+        MaybeAlign SAlign = SGVar->getAlign();
+        MaybeAlign Align = std::nullopt;
+        if (DAlign || SAlign)
+          Align = std::max(DAlign.valueOrOne(), SAlign.valueOrOne());
+
         SGVar->setAlignment(Align);
         DGVar->setAlignment(Align);
       }
     }
 
     GlobalValue::VisibilityTypes Visibility =
         getMinVisibility(DGV->getVisibility(), GV.getVisibility());
     DGV->setVisibility(Visibility);

llvm/lib/Object/IRSymtab.cpp

Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
 
   if (Flags & object::BasicSymbolRef::SF_Common) {
     auto *GVar = dyn_cast<GlobalVariable>(GV);
     if (!GVar)
       return make_error<StringError>("Only variables can have common linkage!",
                                      inconvertibleErrorCode());
     Uncommon().CommonSize =
         GV->getParent()->getDataLayout().getTypeAllocSize(GV->getValueType());
-    Uncommon().CommonAlign = GVar->getAlignment();
+    Uncommon().CommonAlign = GVar->getAlign() ? GVar->getAlign()->value() : 0;
   }
 
   const GlobalObject *GO = GV->getAliaseeObject();
   if (!GO) {
     if (isa<GlobalIFunc>(GV))
       GO = cast<GlobalIFunc>(GV)->getResolverFunction();
     if (!GO)
       return make_error<StringError>("Unable to determine comdat of alias!",

llvm/lib/Target/PowerPC/PPCMIPeephole.cpp

for (MachineInstr &MI : MBB) {
           // The transformation from a zero-extending load to a sign-extending
           // load is only legal when the displacement is a multiple of 4.
           // If the displacement is not at least 4 byte aligned, don't perform
           // the transformation.
           bool IsWordAligned = false;
           if (SrcMI->getOperand(1).isGlobal()) {
             const GlobalObject *GO =
                 dyn_cast<GlobalObject>(SrcMI->getOperand(1).getGlobal());
-            if (GO && GO->getAlignment() >= 4)
+            if (GO && GO->getAlign() && *GO->getAlign() >= 4)
               IsWordAligned = true;
           } else if (SrcMI->getOperand(1).isImm()) {
             int64_t Value = SrcMI->getOperand(1).getImm();
             if (Value % 4 == 0)
               IsWordAligned = true;
           }
 
           // Determine the new opcode. We need to make sure that if the original

llvm/lib/Transforms/IPO/MergeFunctions.cpp

 
 // Replace G with an alias to F (deleting function G)
 void MergeFunctions::writeAlias(Function *F, Function *G) {
   Constant *BitcastF = ConstantExpr::getBitCast(F, G->getType());
   PointerType *PtrType = G->getType();
   auto *GA = GlobalAlias::create(G->getValueType(), PtrType->getAddressSpace(),
                                  G->getLinkage(), "", BitcastF, G->getParent());
 
-  F->setAlignment(MaybeAlign(std::max(F->getAlignment(), G->getAlignment())));
+  const MaybeAlign FAlign = F->getAlign();
+  const MaybeAlign GAlign = G->getAlign();
+  if (FAlign || GAlign)
+    F->setAlignment(std::max(FAlign.valueOrOne(), GAlign.valueOrOne()));
+  else
+    F->setAlignment(std::nullopt);
   GA->takeName(G);
   GA->setVisibility(G->getVisibility());
   GA->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
 
   removeUsers(G);
   G->replaceAllUsesWith(GA);
   G->eraseFromParent();
 
if (F->isInterposable()) {
     // Make them both thunks to the same internal function.
     Function *NewF = Function::Create(F->getFunctionType(), F->getLinkage(),
                                       F->getAddressSpace(), "", F->getParent());
     NewF->copyAttributesFrom(F);
     NewF->takeName(F);
     removeUsers(F);
     F->replaceAllUsesWith(NewF);
 
-    MaybeAlign MaxAlignment(std::max(G->getAlignment(), NewF->getAlignment()));
-
     writeThunkOrAlias(F, G);
     writeThunkOrAlias(F, NewF);
 
-    F->setAlignment(MaxAlignment);
+    const MaybeAlign NewFAlign = NewF->getAlign();
+    const MaybeAlign GAlign = G->getAlign();
+    if (NewFAlign || GAlign)
+      F->setAlignment(std::max(NewFAlign.valueOrOne(), GAlign.valueOrOne()));
+    else
+      F->setAlignment(std::nullopt);
     F->setLinkage(GlobalValue::PrivateLinkage);
     ++NumDoubleWeak;
     ++NumFunctionsMerged;
   } else {
     // For better debugability, under MergeFunctionsPDI, we do not modify G's
     // call sites to point to F even when within the same translation unit.
     if (!G->isInterposable() && !MergeFunctionsPDI) {
       // Functions referred to by llvm.used/llvm.compiler.used are special:

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

if (G->getAddressSpace() &&
       !(TargetTriple.isAMDGPU() && !isUnsupportedAMDGPUAddrspace(G)))
     return false;
   if (GlobalWasGeneratedByCompiler(G)) return false; // Our own globals.
   // Two problems with thread-locals:
   //   - The address of the main thread's copy can't be computed at link-time.
   //   - Need to poison all copies, not just the main thread's one.
   if (G->isThreadLocal()) return false;
   // For now, just ignore this Global if the alignment is large.
-  if (G->getAlignment() > getMinRedzoneSizeForGlobal()) return false;
+  if (G->getAlign() && *G->getAlign() > getMinRedzoneSizeForGlobal()) return false;
 
   // For non-COFF targets, only instrument globals known to be defined by this
   // TU.
   // FIXME: We can instrument comdat globals on ELF if we are using the
   // GC-friendly metadata scheme.
   if (!TargetTriple.isOSBinFormatCOFF()) {
     if (!G->hasExactDefinition() || G->hasComdat())
       return false;

llvm/unittests/IR/ValueTest.cpp

= new GlobalVariable(*M,
                          true,
                          GlobalValue::ExternalLinkage,
                          Constant::getAllOnesValue(Int32Ty),
                          "dummy",
                          nullptr,
                          GlobalVariable::NotThreadLocal,
                          1);
 
-  EXPECT_TRUE(Value::MaximumAlignment == 4294967296ULL);
-  Dummy0->setAlignment(Align(4294967296ULL));
-  EXPECT_EQ(Dummy0->getAlignment(), 4294967296ULL);
+  const Align kMaxAlignment(Value::MaximumAlignment);
+  EXPECT_TRUE(kMaxAlignment.value() == 4294967296ULL);
+  Dummy0->setAlignment(kMaxAlignment);
+  EXPECT_TRUE(Dummy0->getAlign());
+  EXPECT_EQ(*Dummy0->getAlign(), kMaxAlignment);
 
   // Make sure the address space isn't dropped when returning this.
   Constant *Dummy1 = M->getOrInsertGlobal("dummy", Int32Ty);
   EXPECT_EQ(Dummy0, Dummy1);
   EXPECT_EQ(1u, Dummy1->getType()->getPointerAddressSpace());
 
 
   // This one requires a bitcast, but the address space must also stay the same.