RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-29 22:30:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Use create methods since msvc doesn't handle delegating constructors.

Browse Source 
llvm-svn: 209076
This commit is contained in:
Rafael Espindola 2014-05-17 21:29:57 +00:00
parent dff2e7bcac
commit 63b50aa4fa
11 changed files with 59 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/llvm/IR/GlobalAlias.h
View File

@ -33,29 +33,37 @@ class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
void setParent(Module *parent);
GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
const Twine &Name, GlobalObject *Aliasee, Module *Parent);
public:
// allocate space for exactly one operand
void *operator new(size_t s) {
return User::operator new(s, 1);
}
/// If a parent module is specified, the alias is automatically inserted into
/// the end of the specified module's alias list.
GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
const Twine &Name, GlobalObject *Aliasee, Module *Parent);
static GlobalAlias *create(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);
static GlobalAlias *create(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);
static GlobalAlias *create(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);
static GlobalAlias *create(LinkageTypes Linkage, const Twine &Name,
GlobalObject *Aliasee);
// Linkage, Type, Parent and AddressSpace taken from the Aliasee.
GlobalAlias(const Twine &Name, GlobalObject *Aliasee);
static GlobalAlias *create(const Twine &Name, GlobalObject *Aliasee);
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);

4
lib/AsmParser/LLParser.cpp
View File

@ -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, AddrSpace, (GlobalValue::LinkageTypes)Linkage, Name,
Aliasee, /*Parent*/ nullptr));
GlobalAlias::create(Ty, AddrSpace, (GlobalValue::LinkageTypes)Linkage,
Name, Aliasee, /*Parent*/ nullptr));
GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);

4
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -2004,8 +2004,8 @@ error_code BitcodeReader::ParseModule(bool Resume) {
return Error(InvalidTypeForValue);
auto *NewGA =
new GlobalAlias(PTy->getElementType(), PTy->getAddressSpace(),
GetDecodedLinkage(Record[2]), "", TheModule);
GlobalAlias::create(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())

6
lib/IR/Core.cpp
View File

@ -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(), PTy->getAddressSpace(),
GlobalValue::ExternalLinkage, Name,
unwrap<GlobalObject>(Aliasee), unwrap(M)));
return wrap(GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
GlobalValue::ExternalLinkage, Name,
unwrap<GlobalObject>(Aliasee), unwrap(M)));
}
/*--.. Operations on functions .............................................--*/

38
lib/IR/Globals.cpp
View File

@ -225,22 +225,34 @@ GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
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::create(Type *Ty, unsigned AddressSpace,
LinkageTypes Link, const Twine &Name,
GlobalObject *Aliasee, Module *ParentModule) {
return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
}
GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
const Twine &Name, GlobalObject *Aliasee)
: GlobalAlias(Ty, AddressSpace, Linkage, Name, Aliasee,
Aliasee->getParent()) {}
GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
LinkageTypes Linkage, const Twine &Name,
Module *Parent) {
return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
}
GlobalAlias::GlobalAlias(LinkageTypes Link, const Twine &Name,
GlobalObject *Aliasee)
: GlobalAlias(Aliasee->getType()->getElementType(),
Aliasee->getType()->getAddressSpace(), Link, Name, Aliasee) {}
GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
LinkageTypes Linkage, const Twine &Name,
GlobalObject *Aliasee) {
return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
}
GlobalAlias::GlobalAlias(const Twine &Name, GlobalObject *Aliasee)
: GlobalAlias(Aliasee->getLinkage(), Name, Aliasee) {}
GlobalAlias *GlobalAlias::create(LinkageTypes Link, const Twine &Name,
GlobalObject *Aliasee) {
PointerType *PTy = Aliasee->getType();
return create(PTy->getElementType(), PTy->getAddressSpace(), Link, Name,
Aliasee);
}
GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalObject *Aliasee) {
return create(Aliasee->getLinkage(), Name, Aliasee);
}
void GlobalAlias::setParent(Module *parent) {
if (getParent())

5
lib/Linker/LinkModules.cpp
View File

@ -922,8 +922,9 @@ 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(), PTy->getAddressSpace(),
SGA->getLinkage(), SGA->getName(), DstM);
auto *NewDA =
GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
SGA->getLinkage(), SGA->getName(), DstM);
copyGVAttributes(NewDA, SGA);
if (NewVisibility)
NewDA->setVisibility(*NewVisibility);

4
lib/Transforms/IPO/MergeFunctions.cpp
View File

@ -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(), PTy->getAddressSpace(),
G->getLinkage(), "", F);
auto *GA = GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
G->getLinkage(), "", F);
F->setAlignment(std::max(F->getAlignment(), G->getAlignment()));
GA->takeName(G);
GA->setVisibility(G->getVisibility());

5
lib/Transforms/Utils/CloneModule.cpp
View File

@ -68,8 +68,9 @@ 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(), PTy->getAddressSpace(),
I->getLinkage(), I->getName(), New);
auto *GA =
GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
I->getLinkage(), I->getName(), New);
GA->copyAttributesFrom(I);
VMap[I] = GA;
}

2
unittests/IR/ConstantsTest.cpp
View File

@ -274,7 +274,7 @@ TEST(ConstantsTest, ReplaceInAliasTest) {
Type *Int32Ty = Type::getInt32Ty(getGlobalContext());
auto *Global = cast<GlobalObject>(M->getOrInsertGlobal("dummy", Int32Ty));
auto *GA = new GlobalAlias(GlobalValue::ExternalLinkage, "alias", Global);
auto *GA = GlobalAlias::create(GlobalValue::ExternalLinkage, "alias", Global);
EXPECT_DEATH(Global->replaceAllUsesWith(GA),
"replaceAliasUseWith cannot form an alias cycle");
}

2
unittests/IR/VerifierTest.cpp
View File

@ -52,7 +52,7 @@ TEST(VerifierTest, AliasUnnamedAddr) {
GlobalVariable *Aliasee = new GlobalVariable(M, Ty, true,
GlobalValue::ExternalLinkage,
Init, "foo");
auto *GA = new GlobalAlias(GlobalValue::ExternalLinkage, "bar", Aliasee);
auto *GA = GlobalAlias::create(GlobalValue::ExternalLinkage, "bar", Aliasee);
GA->setUnnamedAddr(true);
std::string Error;
raw_string_ostream ErrorOS(Error);

2
unittests/Transforms/Utils/SpecialCaseList.cpp
View File

@ -35,7 +35,7 @@ protected:
}
GlobalAlias *makeAlias(StringRef Name, GlobalObject *Aliasee) {
return new GlobalAlias(GlobalValue::ExternalLinkage, Name, Aliasee);
return GlobalAlias::create(GlobalValue::ExternalLinkage, Name, Aliasee);
}
SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) {