Reduce abuse of default values in the GlobalAlias constructor.

This is in preparation for adding an optional offset.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@209073 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/IR/GlobalAlias.h b/include/llvm/IR/GlobalAlias.h
index 38d3cdf9d7bdf7873800985cf2dfcc0bf13169cc..f5181ab6aaf6313ff0a88ba0280bea43c0be3105 100644 (file)
--- a/include/llvm/IR/GlobalAlias.h
+++ b/include/llvm/IR/GlobalAlias.h
@@ -40,9 +40,22 @@ public:
   }
   /// If a parent module is specified, the alias is automatically inserted into
   /// the end of the specified module's alias list.
-  GlobalAlias(Type *Ty, LinkageTypes Linkage, const Twine &Name = "",
-              GlobalObject *Aliasee = nullptr, Module *Parent = nullptr,
-              unsigned AddressSpace = 0);
+  GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
+              const Twine &Name, GlobalObject *Aliasee, Module *Parent);
+
+  // Without the Aliasee.
+  GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
+              const Twine &Name, Module *Parent);
+
+  // The module is taken from the Aliasee.
+  GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
+              const Twine &Name, GlobalObject *Aliasee);
+
+  // Type, Parent and AddressSpace taken from the Aliasee.
+  GlobalAlias(LinkageTypes Linkage, const Twine &Name, GlobalObject *Aliasee);
+
+  // Linkage, Type, Parent and AddressSpace taken from the Aliasee.
+  GlobalAlias(const Twine &Name, GlobalObject *Aliasee);
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);

diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp
index b457672d7777519fdb8f123e819abe8f7b68031f..b463d49af52b6c285748dbf1a49ecef4188b787c 100644 (file)
--- a/lib/AsmParser/LLParser.cpp
+++ b/lib/AsmParser/LLParser.cpp
@@ -697,8 +697,8 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc,
 
   // Okay, create the alias but do not insert it into the module yet.
   std::unique_ptr<GlobalAlias> GA(
-      new GlobalAlias(Ty, (GlobalValue::LinkageTypes)Linkage, Name, Aliasee,
-                      /*Parent*/ nullptr, AddrSpace));
+      new GlobalAlias(Ty, AddrSpace, (GlobalValue::LinkageTypes)Linkage, Name,
+                      Aliasee, /*Parent*/ nullptr));
   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
 

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index a2bb52c1e9f0d87c19f2059c1229d8d1dac08616..478103f982f539e841dac701c4ae6c7a999aedb8 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -2004,8 +2004,8 @@ error_code BitcodeReader::ParseModule(bool Resume) {
         return Error(InvalidTypeForValue);
 
       auto *NewGA =
-          new GlobalAlias(PTy->getElementType(), GetDecodedLinkage(Record[2]),
-                          "", nullptr, TheModule, PTy->getAddressSpace());
+          new GlobalAlias(PTy->getElementType(), PTy->getAddressSpace(),
+                          GetDecodedLinkage(Record[2]), "", TheModule);
       // Old bitcode files didn't have visibility field.
       // Local linkage must have default visibility.
       if (Record.size() > 3 && !NewGA->hasLocalLinkage())

diff --git a/lib/IR/Core.cpp b/lib/IR/Core.cpp
index 100c9def185bcbf39d779ca03b529a1369938d67..dc3d6f34c883871f82bc99c809d68f82c11e27f8 100644 (file)
--- a/lib/IR/Core.cpp
+++ b/lib/IR/Core.cpp
@@ -1489,9 +1489,9 @@ void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) {
 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
                           const char *Name) {
   auto *PTy = cast<PointerType>(unwrap(Ty));
-  return wrap(new GlobalAlias(
-      PTy->getElementType(), GlobalValue::ExternalLinkage, Name,
-      unwrap<GlobalObject>(Aliasee), unwrap(M), PTy->getAddressSpace()));
+  return wrap(new GlobalAlias(PTy->getElementType(), PTy->getAddressSpace(),
+                              GlobalValue::ExternalLinkage, Name,
+                              unwrap<GlobalObject>(Aliasee), unwrap(M)));
 }
 
 /*--.. Operations on functions .............................................--*/

diff --git a/lib/IR/Globals.cpp b/lib/IR/Globals.cpp
index dd2a4e435ec2a6f378e7aaefbf346372eb69111b..dae3bad5eaee138b432eb58dd73ffb3f6c39bf42 100644 (file)
--- a/lib/IR/Globals.cpp
+++ b/lib/IR/Globals.cpp
@@ -213,9 +213,9 @@ void GlobalVariable::copyAttributesFrom(const GlobalValue *Src) {
 // GlobalAlias Implementation
 //===----------------------------------------------------------------------===//
 
-GlobalAlias::GlobalAlias(Type *Ty, LinkageTypes Link, const Twine &Name,
-                         GlobalObject *Aliasee, Module *ParentModule,
-                         unsigned AddressSpace)
+GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
+                         const Twine &Name, GlobalObject *Aliasee,
+                         Module *ParentModule)
     : GlobalValue(PointerType::get(Ty, AddressSpace), Value::GlobalAliasVal,
                   &Op<0>(), 1, Link, Name) {
   LeakDetector::addGarbageObject(this);
@@ -225,6 +225,23 @@ GlobalAlias::GlobalAlias(Type *Ty, LinkageTypes Link, const Twine &Name,
     ParentModule->getAliasList().push_back(this);
 }
 
+GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
+                         const Twine &Name, Module *Parent)
+    : GlobalAlias(Ty, AddressSpace, Linkage, Name, nullptr, Parent) {}
+
+GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
+                         const Twine &Name, GlobalObject *Aliasee)
+    : GlobalAlias(Ty, AddressSpace, Linkage, Name, Aliasee,
+                  Aliasee->getParent()) {}
+
+GlobalAlias::GlobalAlias(LinkageTypes Link, const Twine &Name,
+                         GlobalObject *Aliasee)
+    : GlobalAlias(Aliasee->getType()->getElementType(),
+                  Aliasee->getType()->getAddressSpace(), Link, Name, Aliasee) {}
+
+GlobalAlias::GlobalAlias(const Twine &Name, GlobalObject *Aliasee)
+    : GlobalAlias(Aliasee->getLinkage(), Name, Aliasee) {}
+
 void GlobalAlias::setParent(Module *parent) {
   if (getParent())
     LeakDetector::addGarbageObject(this);

diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp
index cf49d3fd5565ebb3a00c468b8c82c5951276dae9..518b681046aa10af2c4f6a47aae269ac37ef8170 100644 (file)
--- a/lib/Linker/LinkModules.cpp
+++ b/lib/Linker/LinkModules.cpp
@@ -922,9 +922,8 @@ bool ModuleLinker::linkAliasProto(GlobalAlias *SGA) {
   // If there is no linkage to be performed or we're linking from the source,
   // bring over SGA.
   auto *PTy = cast<PointerType>(TypeMap.get(SGA->getType()));
-  auto *NewDA =
-      new GlobalAlias(PTy->getElementType(), SGA->getLinkage(), SGA->getName(),
-                      /*aliasee*/ nullptr, DstM, PTy->getAddressSpace());
+  auto *NewDA = new GlobalAlias(PTy->getElementType(), PTy->getAddressSpace(),
+                                SGA->getLinkage(), SGA->getName(), DstM);
   copyGVAttributes(NewDA, SGA);
   if (NewVisibility)
     NewDA->setVisibility(*NewVisibility);

diff --git a/lib/Transforms/IPO/MergeFunctions.cpp b/lib/Transforms/IPO/MergeFunctions.cpp
index 83d9a6f749796b221c617851c89119f9da94af2f..bcc2835d3da5b86258ef39c99640fe41bc3ef5b3 100644 (file)
--- a/lib/Transforms/IPO/MergeFunctions.cpp
+++ b/lib/Transforms/IPO/MergeFunctions.cpp
@@ -1328,8 +1328,8 @@ void MergeFunctions::writeThunk(Function *F, Function *G) {
 // Replace G with an alias to F and delete G.
 void MergeFunctions::writeAlias(Function *F, Function *G) {
   PointerType *PTy = G->getType();
-  auto *GA = new GlobalAlias(PTy->getElementType(), G->getLinkage(), "", F,
-                             G->getParent(), PTy->getAddressSpace());
+  auto *GA = new GlobalAlias(PTy->getElementType(), PTy->getAddressSpace(),
+                             G->getLinkage(), "", F);
   F->setAlignment(std::max(F->getAlignment(), G->getAlignment()));
   GA->takeName(G);
   GA->setVisibility(G->getVisibility());

diff --git a/lib/Transforms/Utils/CloneModule.cpp b/lib/Transforms/Utils/CloneModule.cpp
index d4c4c1907aa4d8fb56935c7a8adfa25d4a091d6c..4ccdd9c2b86aee6be7b95746f453f62049473520 100644 (file)
--- a/lib/Transforms/Utils/CloneModule.cpp
+++ b/lib/Transforms/Utils/CloneModule.cpp
@@ -68,9 +68,8 @@ Module *llvm::CloneModule(const Module *M, ValueToValueMapTy &VMap) {
   for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
        I != E; ++I) {
     auto *PTy = cast<PointerType>(I->getType());
-    auto *GA =
-        new GlobalAlias(PTy->getElementType(), I->getLinkage(), I->getName(),
-                        nullptr, New, PTy->getAddressSpace());
+    auto *GA = new GlobalAlias(PTy->getElementType(), PTy->getAddressSpace(),
+                               I->getLinkage(), I->getName(), New);
     GA->copyAttributesFrom(I);
     VMap[I] = GA;
   }

diff --git a/unittests/IR/ConstantsTest.cpp b/unittests/IR/ConstantsTest.cpp
index b225ba923b6309538014c75f4162b09020d8bc4d..abab12202292cf04f3194c4d60c0c5cfee5876b2 100644 (file)
--- a/unittests/IR/ConstantsTest.cpp
+++ b/unittests/IR/ConstantsTest.cpp
@@ -274,8 +274,7 @@ TEST(ConstantsTest, ReplaceInAliasTest) {
 
   Type *Int32Ty = Type::getInt32Ty(getGlobalContext());
   auto *Global = cast<GlobalObject>(M->getOrInsertGlobal("dummy", Int32Ty));
-  auto *GA = new GlobalAlias(Int32Ty, GlobalValue::ExternalLinkage, "alias",
-                             Global, M.get());
+  auto *GA = new GlobalAlias(GlobalValue::ExternalLinkage, "alias", Global);
   EXPECT_DEATH(Global->replaceAllUsesWith(GA),
                "replaceAliasUseWith cannot form an alias cycle");
 }

diff --git a/unittests/IR/VerifierTest.cpp b/unittests/IR/VerifierTest.cpp
index 92f25b3e37aa388e4745d2e0bef92f2cb5f0a669..3499bc315ef772199707d935851d7dc886e91d66 100644 (file)
--- a/unittests/IR/VerifierTest.cpp
+++ b/unittests/IR/VerifierTest.cpp
@@ -52,8 +52,7 @@ TEST(VerifierTest, AliasUnnamedAddr) {
   GlobalVariable *Aliasee = new GlobalVariable(M, Ty, true,
                                                GlobalValue::ExternalLinkage,
                                                Init, "foo");
-  auto *GA =
-      new GlobalAlias(Ty, GlobalValue::ExternalLinkage, "bar", Aliasee, &M);
+  auto *GA = new GlobalAlias(GlobalValue::ExternalLinkage, "bar", Aliasee);
   GA->setUnnamedAddr(true);
   std::string Error;
   raw_string_ostream ErrorOS(Error);

diff --git a/unittests/Transforms/Utils/SpecialCaseList.cpp b/unittests/Transforms/Utils/SpecialCaseList.cpp
index ea8fb3962be8351bc8730b9ddcc70e61ec59e712..190167d0c12bc544cd754eb180b0ea8844879b14 100644 (file)
--- a/unittests/Transforms/Utils/SpecialCaseList.cpp
+++ b/unittests/Transforms/Utils/SpecialCaseList.cpp
@@ -35,9 +35,7 @@ protected:
   }
 
   GlobalAlias *makeAlias(StringRef Name, GlobalObject *Aliasee) {
-    return new GlobalAlias(Aliasee->getType()->getElementType(),
-                           GlobalValue::ExternalLinkage, Name, Aliasee,
-                           Aliasee->getParent());
+    return new GlobalAlias(GlobalValue::ExternalLinkage, Name, Aliasee);
   }
 
   SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) {