[IR][NFC] Rename getBaseObject to getAliaseeObject

[ibookstein]

Summary

To better reflect the meaning of the now-disambiguated
{GlobalValue, GlobalAlias}::getBaseObject after breaking off
GlobalIFunc::getResolverFunction, the function is renamed to
getAliaseeObject.

[ibookstein]

Renamed one additional straggler in clang, removed trailing whitespace elimination hunks.

[ibookstein]

Might I ask that you commit this on my behalf? Got no commit access :)
(I think the test failures are unrelated, they complain about missing file llvm-jitlink o_O)

Author: Itay Bookstein <[e-mail]>

[MaskRay]

Will push next Monday

[nextsilicon-itay-bookstein]

ping :)

[MaskRay]

Sorry that I forgot to push this last Monday. I was then out of town for one week and was just back.

Pushed on your behalf. I checked some large users like Julia/Rust/Swift and many other downstream users and confirmed that none uses the API, so I don't consider adding a compatibility alias.

[MaskRay]

Closed by 40ec1c0f16cb23f8b83fb3d28b195e83991defd9

Forgot to attach Differential Revision:

clang/lib/CodeGen/MicrosoftCXXABI.cpp

#endif
   bool VTableAliasIsRequred =
       !VFTableComesFromAnotherTU && getContext().getLangOpts().RTTIData;
 
   if (llvm::GlobalValue *VFTable =
           CGM.getModule().getNamedGlobal(VFTableName)) {
     VFTablesMap[ID] = VFTable;
     VTable = VTableAliasIsRequred
                  ? cast<llvm::GlobalVariable>(
-                       cast<llvm::GlobalAlias>(VFTable)->getBaseObject())
+                       cast<llvm::GlobalAlias>(VFTable)->getAliaseeObject())
                  : cast<llvm::GlobalVariable>(VFTable);
     return VTable;
   }
 
   const VTableLayout &VTLayout =
       VTContext.getVFTableLayout(RD, VFPtr->FullOffsetInMDC);
   llvm::GlobalValue::LinkageTypes VTableLinkage =
       VTableAliasIsRequred ? llvm::GlobalValue::PrivateLinkage : VFTableLinkage;

llvm/include/llvm/IR/GlobalAlias.h

public:
   void setAliasee(Constant *Aliasee);
   const Constant *getAliasee() const {
     return getIndirectSymbol();
   }
   Constant *getAliasee() {
     return getIndirectSymbol();
   }
 
-  const GlobalObject *getBaseObject() const;
-  GlobalObject *getBaseObject() {
+  const GlobalObject *getAliaseeObject() const;
+  GlobalObject *getAliaseeObject() {
     return const_cast<GlobalObject *>(
-        static_cast<const GlobalAlias *>(this)->getBaseObject());
+        static_cast<const GlobalAlias *>(this)->getAliaseeObject());
   }
 
   static bool isValidLinkage(LinkageTypes L) {
     return isExternalLinkage(L) || isLocalLinkage(L) ||
       isWeakLinkage(L) || isLinkOnceLinkage(L);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalAliasVal;
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_GLOBALALIAS_H

llvm/include/llvm/IR/GlobalIndirectSymbol.h

public:
   const Constant *getIndirectSymbol() const {
     return getOperand(0);
   }
   Constant *getIndirectSymbol() {
     return const_cast<Constant *>(
           static_cast<const GlobalIndirectSymbol *>(this)->getIndirectSymbol());
   }
 
-  const GlobalObject *getBaseObject() const;
-  GlobalObject *getBaseObject() {
+  const GlobalObject *getAliaseeObject() const;
+  GlobalObject *getAliaseeObject() {
     return const_cast<GlobalObject *>(
-              static_cast<const GlobalIndirectSymbol *>(this)->getBaseObject());
+        static_cast<const GlobalIndirectSymbol *>(this)->getAliaseeObject());
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalAliasVal ||
            V->getValueID() == Value::GlobalIFuncVal;
   }
 };

llvm/include/llvm/IR/GlobalValue.h

/// @}
   ///
   /// NB! Ideally this should not be used at the IR level at all.  If you're
   /// interested in optimization constraints implied by the linker's ability to
   /// choose an implementation, prefer using \c hasExactDefinition.
   bool isStrongDefinitionForLinker() const {
     return !(isDeclarationForLinker() || isWeakForLinker());
   }
 
-  const GlobalObject *getBaseObject() const;
-  GlobalObject *getBaseObject() {
+  const GlobalObject *getAliaseeObject() const;
+  GlobalObject *getAliaseeObject() {
     return const_cast<GlobalObject *>(
-                       static_cast<const GlobalValue *>(this)->getBaseObject());
+        static_cast<const GlobalValue *>(this)->getAliaseeObject());
   }
 
   /// Returns whether this is a reference to an absolute symbol.
   bool isAbsoluteSymbolRef() const;
 
   /// If this is an absolute symbol reference, returns the range of the symbol,
   /// otherwise returns None.
   Optional<ConstantRange> getAbsoluteSymbolRange() const;

llvm/lib/Analysis/ConstantFolding.cpp

 
 /// Strip the pointer casts, but preserve the address space information.
 Constant *StripPtrCastKeepAS(Constant *Ptr, bool ForLoadOperand) {
   assert(Ptr->getType()->isPointerTy() && "Not a pointer type");
   auto *OldPtrTy = cast<PointerType>(Ptr->getType());
   Ptr = cast<Constant>(Ptr->stripPointerCasts());
   if (ForLoadOperand) {
     while (isa<GlobalAlias>(Ptr) && !cast<GlobalAlias>(Ptr)->isInterposable() &&
-           !cast<GlobalAlias>(Ptr)->getBaseObject()->isInterposable()) {
+           !cast<GlobalAlias>(Ptr)->getAliaseeObject()->isInterposable()) {
       Ptr = cast<GlobalAlias>(Ptr)->getAliasee();
     }
   }
 
   auto *NewPtrTy = cast<PointerType>(Ptr->getType());
 
   // Preserve the address space number of the pointer.
   if (NewPtrTy->getAddressSpace() != OldPtrTy->getAddressSpace()) {

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

for (const Instruction &I : BB) {
         CalledValue = CalledValue->stripPointerCasts();
         // Stripping pointer casts can reveal a called function.
         CalledFunction = dyn_cast<Function>(CalledValue);
       }
       // Check if this is an alias to a function. If so, get the
       // called aliasee for the checks below.
       if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
         assert(!CalledFunction && "Expected null called function in callsite for alias");
-        CalledFunction = dyn_cast<Function>(GA->getBaseObject());
+        CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
       }
       // Check if this is a direct call to a known function or a known
       // intrinsic, or an indirect call with profile data.
       if (CalledFunction) {
         if (CI && CalledFunction->isIntrinsic()) {
           addIntrinsicToSummary(
               CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
               TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);

 computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A,
                     DenseSet<GlobalValue::GUID> &CantBePromoted) {
   bool NonRenamableLocal = isNonRenamableLocal(A);
   GlobalValueSummary::GVFlags Flags(
       A.getLinkage(), A.getVisibility(), NonRenamableLocal,
       /* Live = */ false, A.isDSOLocal(),
       A.hasLinkOnceODRLinkage() && A.hasGlobalUnnamedAddr());
   auto AS = std::make_unique<AliasSummary>(Flags);
-  auto *Aliasee = A.getBaseObject();
+  auto *Aliasee = A.getAliaseeObject();
   auto AliaseeVI = Index.getValueInfo(Aliasee->getGUID());
   assert(AliaseeVI && "Alias expects aliasee summary to be available");
   assert(AliaseeVI.getSummaryList().size() == 1 &&
          "Expected a single entry per aliasee in per-module index");
   AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
   if (NonRenamableLocal)
     CantBePromoted.insert(A.getGUID());
   Index.addGlobalValueSummary(A, std::move(AS));

llvm/lib/Analysis/StackSafetyAnalysis.cpp

const Function *findCalleeInModule(const GlobalValue *GV) {
   while (GV) {
     if (GV->isDeclaration() || GV->isInterposable() || !GV->isDSOLocal())
       return nullptr;
     if (const Function *F = dyn_cast<Function>(GV))
       return F;
     const GlobalAlias *A = dyn_cast<GlobalAlias>(GV);
     if (!A)
       return nullptr;
-    GV = A->getBaseObject();
+    GV = A->getAliaseeObject();
     if (GV == A)
       return nullptr;
   }
   return nullptr;
 }
 
 const ConstantRange *findParamAccess(const FunctionSummary &FS,
                                      uint32_t ParamNo) {

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
 
   // Capture references from GlobalVariable initializers, which are outside
   // of a function scope.
   for (const GlobalVariable &G : M.globals())
     writeModuleLevelReferences(G, NameVals, FSModRefsAbbrev,
                                FSModVTableRefsAbbrev);
 
   for (const GlobalAlias &A : M.aliases()) {
-    auto *Aliasee = A.getBaseObject();
+    auto *Aliasee = A.getAliaseeObject();
     if (!Aliasee->hasName())
       // Nameless function don't have an entry in the summary, skip it.
       continue;
     auto AliasId = VE.getValueID(&A);
     auto AliaseeId = VE.getValueID(Aliasee);
     NameVals.push_back(AliasId);
     auto *Summary = Index->getGlobalValueSummary(A);
     AliasSummary *AS = cast<AliasSummary>(Summary);

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (LocalAlias != Name)
     OutStreamer->emitAssignment(LocalAlias, Expr);
 
   if (auto *GA = dyn_cast<GlobalAlias>(&GIS)) {
     // If the aliasee does not correspond to a symbol in the output, i.e. the
     // alias is not of an object or the aliased object is private, then set the
     // size of the alias symbol from the type of the alias. We don't do this in
     // other situations as the alias and aliasee having differing types but same
     // size may be intentional.
-    const GlobalObject *BaseObject = GA->getBaseObject();
+    const GlobalObject *Aliasee = GA->getAliaseeObject();
     if (MAI->hasDotTypeDotSizeDirective() && GA->getValueType()->isSized() &&
-        (!BaseObject || BaseObject->hasPrivateLinkage())) {
+        (!Aliasee || Aliasee->hasPrivateLinkage())) {
       const DataLayout &DL = M.getDataLayout();
       uint64_t Size = DL.getTypeAllocSize(GA->getValueType());
       OutStreamer->emitELFSize(Name, MCConstantExpr::create(Size, OutContext));
     }
   }
 }
 
 void AsmPrinter::emitRemarksSection(remarks::RemarkStreamer &RS) {

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
   // we don't allow it.
   return false;
 }
 
 void TargetLoweringObjectFileMachO::getNameWithPrefix(
     SmallVectorImpl<char> &OutName, const GlobalValue *GV,
     const TargetMachine &TM) const {
   bool CannotUsePrivateLabel = true;
-  if (auto *GO = GV->getBaseObject()) {
+  if (auto *GO = GV->getAliaseeObject()) {
     SectionKind GOKind = TargetLoweringObjectFile::getKindForGlobal(GO, TM);
     const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
     CannotUsePrivateLabel =
         !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
   }
   getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
 }
 
static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
 
   return ComdatGV;
 }
 
 static int getSelectionForCOFF(const GlobalValue *GV) {
   if (const Comdat *C = GV->getComdat()) {
     const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
     if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
-      ComdatKey = GA->getBaseObject();
+      ComdatKey = GA->getAliaseeObject();
     if (ComdatKey == GV) {
       switch (C->getSelectionKind()) {
       case Comdat::Any:
         return COFF::IMAGE_COMDAT_SELECT_ANY;
       case Comdat::ExactMatch:
         return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
       case Comdat::Largest:
         return COFF::IMAGE_COMDAT_SELECT_LARGEST;
case GlobalValue::AppendingLinkage:
     report_fatal_error(
         "There is no mapping that implements AppendingLinkage for XCOFF.");
   }
   llvm_unreachable("Unknown linkage type!");
 }
 
 MCSymbol *TargetLoweringObjectFileXCOFF::getFunctionEntryPointSymbol(
     const GlobalValue *Func, const TargetMachine &TM) const {
-  assert(
-      (isa<Function>(Func) ||
+  assert((isa<Function>(Func) ||
           (isa<GlobalAlias>(Func) &&
-        isa_and_nonnull<Function>(cast<GlobalAlias>(Func)->getBaseObject()))) &&
+           isa_and_nonnull<Function>(
+               cast<GlobalAlias>(Func)->getAliaseeObject()))) &&
          "Func must be a function or an alias which has a function as base "
          "object.");
 
   SmallString<128> NameStr;
   NameStr.push_back('.');
   getNameWithPrefix(NameStr, Func, TM);
 
   // When -function-sections is enabled and explicit section is not specified,
   // it's not necessary to emit function entry point label any more. We will use
   // function entry point csect instead. And for function delcarations, the

llvm/lib/IR/Globals.cpp

 std::string GlobalValue::getGlobalIdentifier() const {
   return getGlobalIdentifier(getName(), getLinkage(),
                              getParent()->getSourceFileName());
 }
 
 StringRef GlobalValue::getSection() const {
   if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     // In general we cannot compute this at the IR level, but we try.
-    if (const GlobalObject *GO = GA->getBaseObject())
+    if (const GlobalObject *GO = GA->getAliaseeObject())
       return GO->getSection();
     return "";
   }
   return cast<GlobalObject>(this)->getSection();
 }
 
 const Comdat *GlobalValue::getComdat() const {
   if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     // In general we cannot compute this at the IR level, but we try.
-    if (const GlobalObject *GO = GA->getBaseObject())
+    if (const GlobalObject *GO = GA->getAliaseeObject())
       return const_cast<GlobalObject *>(GO)->getComdat();
     return nullptr;
   }
   // ifunc and its resolver are separate things so don't use resolver comdat.
   if (isa<GlobalIFunc>(this))
     return nullptr;
   return cast<GlobalObject>(this)->getComdat();
 }
bool GlobalObject::canIncreaseAlignment() const {
   bool isELF =
       (!Parent || Triple(Parent->getTargetTriple()).isOSBinFormatELF());
   if (isELF && !isDSOLocal())
     return false;
 
   return true;
 }
 
-const GlobalObject *GlobalValue::getBaseObject() const {
+const GlobalObject *GlobalValue::getAliaseeObject() const {
   if (auto *GO = dyn_cast<GlobalObject>(this))
     return GO;
   if (auto *GA = dyn_cast<GlobalAlias>(this))
-    return GA->getBaseObject();
+    return GA->getAliaseeObject();
   return nullptr;
 }
 
 bool GlobalValue::isAbsoluteSymbolRef() const {
   auto *GO = dyn_cast<GlobalObject>(this);
   if (!GO)
     return false;
 

 }
 
 void GlobalAlias::setAliasee(Constant *Aliasee) {
   assert((!Aliasee || Aliasee->getType() == getType()) &&
          "Alias and aliasee types should match!");
   setIndirectSymbol(Aliasee);
 }
 
-const GlobalObject *GlobalAlias::getBaseObject() const {
+const GlobalObject *GlobalAlias::getAliaseeObject() const {
   DenseSet<const GlobalAlias *> Aliases;
   return findBaseObject(getOperand(0), Aliases);
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalIFunc Implementation
 //===----------------------------------------------------------------------===//
 

llvm/lib/LTO/LTO.cpp

LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
   SymTab.addModule(&M);
 
   for (GlobalVariable &GV : M.globals())
     if (GV.hasAppendingLinkage())
       Mod.Keep.push_back(&GV);
 
   DenseSet<GlobalObject *> AliasedGlobals;
   for (auto &GA : M.aliases())
-    if (GlobalObject *GO = GA.getBaseObject())
+    if (GlobalObject *GO = GA.getAliaseeObject())
       AliasedGlobals.insert(GO);
 
   // In this function we need IR GlobalValues matching the symbols in Syms
   // (which is not backed by a module), so we need to enumerate them in the same
   // order. The symbol enumeration order of a ModuleSymbolTable intentionally
   // matches the order of an irsymtab, but when we read the irsymtab in
   // InputFile::create we omit some symbols that are irrelevant to LTO. The
   // Skip() function skips the same symbols from the module as InputFile does

llvm/lib/Linker/LinkModules.cpp

if (A == GlobalValue::ProtectedVisibility ||
     return GlobalValue::ProtectedVisibility;
   return GlobalValue::DefaultVisibility;
 }
 
 bool ModuleLinker::getComdatLeader(Module &M, StringRef ComdatName,
                                    const GlobalVariable *&GVar) {
   const GlobalValue *GVal = M.getNamedValue(ComdatName);
   if (const auto *GA = dyn_cast_or_null<GlobalAlias>(GVal)) {
-    GVal = GA->getBaseObject();
+    GVal = GA->getAliaseeObject();
     if (!GVal)
       // We cannot resolve the size of the aliasee yet.
       return emitError("Linking COMDATs named '" + ComdatName +
                        "': COMDAT key involves incomputable alias size.");
   }
 
   GVar = dyn_cast_or_null<GlobalVariable>(GVal);
   if (!GVar)

llvm/lib/Object/IRSymtab.cpp

if (Flags & object::BasicSymbolRef::SF_Common) {
     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();
   }
 
-  const GlobalObject *Base = GV->getBaseObject();
-  if (!Base) {
+  const GlobalObject *GO = GV->getAliaseeObject();
+  if (!GO) {
     if (isa<GlobalIFunc>(GV))
-      Base = cast<GlobalIFunc>(GV)->getResolverFunction();
-    if (!Base)
+      GO = cast<GlobalIFunc>(GV)->getResolverFunction();
+    if (!GO)
       return make_error<StringError>("Unable to determine comdat of alias!",
                                      inconvertibleErrorCode());
   }
-  if (const Comdat *C = Base->getComdat()) {
+  if (const Comdat *C = GO->getComdat()) {
     Expected<int> ComdatIndexOrErr = getComdatIndex(C, GV->getParent());
     if (!ComdatIndexOrErr)
       return ComdatIndexOrErr.takeError();
     Sym.ComdatIndex = *ComdatIndexOrErr;
   }
 
   if (TT.isOSBinFormatCOFF()) {
     emitLinkerFlagsForGlobalCOFF(COFFLinkerOptsOS, GV, TT, Mang);
 
     if ((Flags & object::BasicSymbolRef::SF_Weak) &&
         (Flags & object::BasicSymbolRef::SF_Indirect)) {
       auto *Fallback = dyn_cast<GlobalValue>(
           cast<GlobalAlias>(GV)->getAliasee()->stripPointerCasts());
       if (!Fallback)
         return make_error<StringError>("Invalid weak external",
                                        inconvertibleErrorCode());
       std::string FallbackName;
       raw_string_ostream OS(FallbackName);
       Msymtab.printSymbolName(OS, Fallback);
       OS.flush();
       setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));
     }
   }
 
-  if (!Base->getSection().empty())
-    setStr(Uncommon().SectionName, Saver.save(Base->getSection()));
+  if (!GO->getSection().empty())
+    setStr(Uncommon().SectionName, Saver.save(GO->getSection()));
 
   return Error::success();
 }
 
 Error Builder::build(ArrayRef<Module *> IRMods) {
   storage::Header Hdr;
 
   assert(!IRMods.empty());

llvm/lib/Object/ModuleSymbolTable.cpp

uint32_t ModuleSymbolTable::getSymbolFlags(Symbol S) const {
   if (GV->isDeclarationForLinker())
     Res |= BasicSymbolRef::SF_Undefined;
   else if (GV->hasHiddenVisibility() && !GV->hasLocalLinkage())
     Res |= BasicSymbolRef::SF_Hidden;
   if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
     if (GVar->isConstant())
       Res |= BasicSymbolRef::SF_Const;
   }
-  if (isa_and_nonnull<Function>(GV->getBaseObject()) || isa<GlobalIFunc>(GV))
+  if (isa_and_nonnull<Function>(GV->getAliaseeObject()) || isa<GlobalIFunc>(GV))
     Res |= BasicSymbolRef::SF_Executable;
   if (isa<GlobalAlias>(GV))
     Res |= BasicSymbolRef::SF_Indirect;
   if (GV->hasPrivateLinkage())
     Res |= BasicSymbolRef::SF_FormatSpecific;
   if (!GV->hasLocalLinkage())
     Res |= BasicSymbolRef::SF_Global;
   if (GV->hasCommonLinkage())

llvm/lib/Target/ARM/ARMISelLowering.cpp

AFI->setPromotedConstpoolIncrease(AFI->getPromotedConstpoolIncrease() +
                                       PaddedSize - 4);
   }
   ++NumConstpoolPromoted;
   return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
 }
 
 bool ARMTargetLowering::isReadOnly(const GlobalValue *GV) const {
   if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
-    if (!(GV = GA->getBaseObject()))
+    if (!(GV = GA->getAliaseeObject()))
       return false;
   if (const auto *V = dyn_cast<GlobalVariable>(GV))
     return V->isConstant();
   return isa<Function>(GV);
 }
 
 SDValue ARMTargetLowering::LowerGlobalAddress(SDValue Op,
                                               SelectionDAG &DAG) const {

llvm/lib/Target/Hexagon/HexagonISelLowering.cpp

HexagonTargetLowering::LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const {
   auto *GV = GAN->getGlobal();
   int64_t Offset = GAN->getOffset();
 
   auto &HLOF = *HTM.getObjFileLowering();
   Reloc::Model RM = HTM.getRelocationModel();
 
   if (RM == Reloc::Static) {
     SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset);
-    const GlobalObject *GO = GV->getBaseObject();
+    const GlobalObject *GO = GV->getAliaseeObject();
     if (GO && Subtarget.useSmallData() && HLOF.isGlobalInSmallSection(GO, HTM))
       return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, GA);
     return DAG.getNode(HexagonISD::CONST32, dl, PtrVT, GA);
   }
 
   bool UsePCRel = getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV);
   if (UsePCRel) {
     SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset,

llvm/lib/Target/Lanai/LanaiISelLowering.cpp

SDValue LanaiTargetLowering::LowerGlobalAddress(SDValue Op,
   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
 
   const LanaiTargetObjectFile *TLOF =
       static_cast<const LanaiTargetObjectFile *>(
           getTargetMachine().getObjFileLowering());
 
   // If the code model is small or global variable will be placed in the small
   // section, then assume address will fit in 21-bits.
-  const GlobalObject *GO = GV->getBaseObject();
+  const GlobalObject *GO = GV->getAliaseeObject();
   if (TLOF->isGlobalInSmallSection(GO, getTargetMachine())) {
     SDValue Small = DAG.getTargetGlobalAddress(
         GV, DL, getPointerTy(DAG.getDataLayout()), Offset, LanaiII::MO_NO_FLAG);
     return DAG.getNode(ISD::OR, DL, MVT::i32,
                        DAG.getRegister(Lanai::R0, MVT::i32),
                        DAG.getNode(LanaiISD::SMALL, DL, MVT::i32, Small));
   } else {
     uint8_t OpFlagHi = LanaiII::MO_ABS_HI;

llvm/lib/Target/Mips/MipsISelLowering.cpp

SDValue MipsTargetLowering::lowerGlobalAddress(SDValue Op,
   EVT Ty = Op.getValueType();
   GlobalAddressSDNode *N = cast<GlobalAddressSDNode>(Op);
   const GlobalValue *GV = N->getGlobal();
 
   if (!isPositionIndependent()) {
     const MipsTargetObjectFile *TLOF =
         static_cast<const MipsTargetObjectFile *>(
             getTargetMachine().getObjFileLowering());
-    const GlobalObject *GO = GV->getBaseObject();
+    const GlobalObject *GO = GV->getAliaseeObject();
     if (GO && TLOF->IsGlobalInSmallSection(GO, getTargetMachine()))
       // %gp_rel relocation
       return getAddrGPRel(N, SDLoc(N), Ty, DAG, ABI.IsN64());
 
                                 // %hi/%lo relocation
     return Subtarget.hasSym32() ? getAddrNonPIC(N, SDLoc(N), Ty, DAG)
                                 // %highest/%higher/%hi/%lo relocation
                                 : getAddrNonPICSym64(N, SDLoc(N), Ty, DAG);

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

for (const auto &G : M.globals()) {
     setCsectAlignment(&G);
   }
 
   for (const auto &F : M)
     setCsectAlignment(&F);
 
   // Construct an aliasing list for each GlobalObject.
   for (const auto &Alias : M.aliases()) {
-    const GlobalObject *Base = Alias.getBaseObject();
+    const GlobalObject *Base = Alias.getAliaseeObject();
     if (!Base)
       report_fatal_error(
           "alias without a base object is not yet supported on AIX");
     GOAliasMap[Base].push_back(&Alias);
   }
 
   return Result;
 }

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

#endif
   // Functions with PC Relative enabled may clobber the TOC in the same DSO.
   // We may need a TOC restore in the situation where the caller requires a
   // valid TOC but the callee is PC Relative and does not.
   const Function *F = dyn_cast<Function>(GV);
   const GlobalAlias *Alias = dyn_cast<GlobalAlias>(GV);
 
   // If we have an Alias we can try to get the function from there.
   if (Alias) {
-    const GlobalObject *GlobalObj = Alias->getBaseObject();
+    const GlobalObject *GlobalObj = Alias->getAliaseeObject();
     F = dyn_cast<Function>(GlobalObj);
   }
 
   // If we still have no valid function pointer we do not have enough
   // information to determine if the callee uses PC Relative calls so we must
   // assume that it does.
   if (!F)
     return false;

llvm/lib/Transforms/IPO/FunctionImport.cpp

void llvm::thinLTOInternalizeModule(Module &TheModule,
 
   // FIXME: See if we can just internalize directly here via linkage changes
   // based on the index, rather than invoking internalizeModule.
   internalizeModule(TheModule, MustPreserveGV);
 }
 
 /// Make alias a clone of its aliasee.
 static Function *replaceAliasWithAliasee(Module *SrcModule, GlobalAlias *GA) {
-  Function *Fn = cast<Function>(GA->getBaseObject());
+  Function *Fn = cast<Function>(GA->getAliaseeObject());
 
   ValueToValueMapTy VMap;
   Function *NewFn = CloneFunction(Fn, VMap);
   // Clone should use the original alias's linkage, visibility and name, and we
   // ensure all uses of alias instead use the new clone (casted if necessary).
   NewFn->setLinkage(GA->getLinkage());
   NewFn->setVisibility(GA->getVisibility());
   GA->replaceAllUsesWith(ConstantExpr::getBitCast(NewFn, GA->getType()));
for (GlobalAlias &GA : SrcModule->aliases()) {
       auto Import = ImportGUIDs.count(GUID);
       LLVM_DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing alias "
                         << GUID << " " << GA.getName() << " from "
                         << SrcModule->getSourceFileName() << "\n");
       if (Import) {
         if (Error Err = GA.materialize())
           return std::move(Err);
         // Import alias as a copy of its aliasee.
-        GlobalObject *Base = GA.getBaseObject();
-        if (Error Err = Base->materialize())
+        GlobalObject *GO = GA.getAliaseeObject();
+        if (Error Err = GO->materialize())
           return std::move(Err);
         auto *Fn = replaceAliasWithAliasee(SrcModule.get(), &GA);
-        LLVM_DEBUG(dbgs() << "Is importing aliasee fn " << Base->getGUID()
-                          << " " << Base->getName() << " from "
+        LLVM_DEBUG(dbgs() << "Is importing aliasee fn " << GO->getGUID() << " "
+                          << GO->getName() << " from "
                           << SrcModule->getSourceFileName() << "\n");
         if (EnableImportMetadata) {
           // Add 'thinlto_src_module' metadata for statistics and debugging.
           Fn->setMetadata(
               "thinlto_src_module",
               MDNode::get(DestModule.getContext(),
                           {MDString::get(DestModule.getContext(),
                                          SrcModule->getSourceFileName())}));

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

void splitAndWriteThinLTOBitcode(
   ValueToValueMapTy VMap;
   std::unique_ptr<Module> MergedM(
       CloneModule(M, VMap, [&](const GlobalValue *GV) -> bool {
         if (const auto *C = GV->getComdat())
           if (MergedMComdats.count(C))
             return true;
         if (auto *F = dyn_cast<Function>(GV))
           return EligibleVirtualFns.count(F);
-        if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getBaseObject()))
+        if (auto *GVar =
+                dyn_cast_or_null<GlobalVariable>(GV->getAliaseeObject()))
           return HasTypeMetadata(GVar);
         return false;
       }));
   StripDebugInfo(*MergedM);
   MergedM->setModuleInlineAsm("");
 
   // Clone any llvm.*used globals to ensure the included values are
   // not deleted.
void splitAndWriteThinLTOBitcode(
   SetVector<GlobalValue *> CfiFunctions;
   for (auto &F : M)
     if ((!F.hasLocalLinkage() || F.hasAddressTaken()) && HasTypeMetadata(&F))
       CfiFunctions.insert(&F);
 
   // Remove all globals with type metadata, globals with comdats that live in
   // MergedM, and aliases pointing to such globals from the thin LTO module.
   filterModule(&M, [&](const GlobalValue *GV) {
-    if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getBaseObject()))
+    if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getAliaseeObject()))
       if (HasTypeMetadata(GVar))
         return false;
     if (const auto *C = GV->getComdat())
       if (MergedMComdats.count(C))
         return false;
     return true;
   });
 

llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

bool DataFlowSanitizer::runImpl(Module &M) {
   // Give function aliases prefixes when necessary, and build wrappers where the
   // instrumentedness is inconsistent.
   for (Module::alias_iterator AI = M.alias_begin(), AE = M.alias_end();
        AI != AE;) {
     GlobalAlias *GA = &*AI;
     ++AI;
     // Don't stop on weak.  We assume people aren't playing games with the
     // instrumentedness of overridden weak aliases.
-    auto *F = dyn_cast<Function>(GA->getBaseObject());
+    auto *F = dyn_cast<Function>(GA->getAliaseeObject());
     if (!F)
       continue;
 
     bool GAInst = isInstrumented(GA), FInst = isInstrumented(F);
     if (GAInst && FInst) {
       addGlobalNameSuffix(GA);
     } else if (GAInst != FInst) {
       // Non-instrumented alias of an instrumented function, or vice versa.

llvm/lib/Transforms/Utils/SplitModule.cpp

if (const Comdat *C = GV.getComdat()) {
         GVtoClusterMap.unionSets(Member, &GV);
       else
         Member = &GV;
     }
 
     // For aliases we should not separate them from their aliasees regardless
     // of linkage.
     if (auto *GIS = dyn_cast<GlobalAlias>(&GV)) {
-      if (const GlobalObject *Base = GIS->getBaseObject())
-        GVtoClusterMap.unionSets(&GV, Base);
+      if (const GlobalObject *Aliasee = GIS->getAliaseeObject())
+        GVtoClusterMap.unionSets(&GV, Aliasee);
     } else if (auto *GIS = dyn_cast<GlobalIFunc>(&GV)) {
       GVtoClusterMap.unionSets(&GV, GIS->getResolverFunction());
     }
 
     if (const Function *F = dyn_cast<Function>(&GV)) {
       for (const BasicBlock &BB : *F) {
         BlockAddress *BA = BlockAddress::lookup(&BB);
         if (!BA || !BA->isConstantUsed())
static void externalize(GlobalValue *GV) {
   // give a distinct name to each such entity.
   if (!GV->hasName())
     GV->setName("__llvmsplit_unnamed");
 }
 
 // Returns whether GV should be in partition (0-based) I of N.
 static bool isInPartition(const GlobalValue *GV, unsigned I, unsigned N) {
   if (auto *GIS = dyn_cast<GlobalAlias>(GV)) {
-    if (const GlobalObject *Base = GIS->getBaseObject())
+    if (const GlobalObject *Base = GIS->getAliaseeObject())
       GV = Base;
   } else if (auto *GIS = dyn_cast<GlobalIFunc>(GV)) {
     GV = GIS->getResolverFunction();
   }
 
   StringRef Name;
   if (const Comdat *C = GV->getComdat())
     Name = C->getName();

llvm/tools/bugpoint/CrashDebugger.cpp

if (!ReplaceFuncsWithNull) {
     // with...
     for (Function &I : *M)
       if (!I.isDeclaration() && !Functions.count(&I))
         DeleteFunctionBody(&I);
   } else {
     std::vector<GlobalValue *> ToRemove;
     // First, remove aliases to functions we're about to purge.
     for (GlobalAlias &Alias : M->aliases()) {
-      GlobalObject *Root = Alias.getBaseObject();
+      GlobalObject *Root = Alias.getAliaseeObject();
       Function *F = dyn_cast_or_null<Function>(Root);
       if (F) {
         if (Functions.count(F))
           // We're keeping this function.
           continue;
       } else if (Root->isNullValue()) {
         // This referenced a globalalias that we've already replaced,
         // so we still need to replace this alias.