replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "[opaque pointer type] Pass GlobalAlias the actual pointer type rather than decomposing it into pointee type + address space" 

This was a flawed change - it just caused the getElementType call to be
deferred until later, when we really need to remove it. Now that the IR
for GlobalAliases has been updated, the root cause is addressed that way
instead and this change is no longer needed (and in fact gets in the way
- because we want to pass the pointee type directly down further).

Follow up patches to push this through GlobalValue, bitcode format, etc,
will come along soon.

This reverts commit 236160.

llvm-svn: 247585
This commit is contained in:
David Blaikie 2015-09-14 18:01:59 +00:00
parent c23a8b2d39
commit 16a2f3e302
11 changed files with 59 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -33,8 +33,8 @@ class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
void setParent(Module *parent);
GlobalAlias(PointerType *Ty, LinkageTypes Linkage, const Twine &Name,
Constant *Aliasee, Module *Parent);
GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
const Twine &Name, Constant *Aliasee, Module *Parent);
public:
// allocate space for exactly one operand
@ -44,17 +44,19 @@ public:
/// If a parent module is specified, the alias is automatically inserted into
/// the end of the specified module's alias list.
static GlobalAlias *create(PointerType *Ty, LinkageTypes Linkage,
const Twine &Name, Constant *Aliasee,
Module *Parent);
static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
LinkageTypes Linkage, const Twine &Name,
Constant *Aliasee, Module *Parent);
// Without the Aliasee.
static GlobalAlias *create(PointerType *Ty, 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.
static GlobalAlias *create(PointerType *Ty, LinkageTypes Linkage,
const Twine &Name, GlobalValue *Aliasee);
static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
LinkageTypes Linkage, const Twine &Name,
GlobalValue *Aliasee);
// Type, Parent and AddressSpace taken from the Aliasee.
static GlobalAlias *create(LinkageTypes Linkage, const Twine &Name,

5
llvm/lib/AsmParser/LLParser.cpp
View File

@ -706,6 +706,7 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
auto *PTy = dyn_cast<PointerType>(AliaseeType);
if (!PTy)
return Error(AliaseeLoc, "An alias must have pointer type");
unsigned AddrSpace = PTy->getAddressSpace();
if (Ty != PTy->getElementType())
return Error(
@ -714,8 +715,8 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
// Okay, create the alias but do not insert it into the module yet.
std::unique_ptr<GlobalAlias> GA(
GlobalAlias::create(PTy, (GlobalValue::LinkageTypes)Linkage, Name,
Aliasee, /*Parent*/ nullptr));
GlobalAlias::create(Ty, AddrSpace, (GlobalValue::LinkageTypes)Linkage,
Name, Aliasee, /*Parent*/ nullptr));
GA->setThreadLocalMode(TLM);
GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);

3
llvm/lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -3159,7 +3159,8 @@ std::error_code BitcodeReader::parseModule(bool Resume,
return error("Invalid type for value");
auto *NewGA =
GlobalAlias::create(PTy, 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())

3
llvm/lib/CodeGen/GlobalMerge.cpp
View File

@ -462,7 +462,8 @@ bool GlobalMerge::doMerge(const SmallVectorImpl<GlobalVariable *> &Globals,
if (Linkage != GlobalValue::InternalLinkage ||
!TM->getTargetTriple().isOSBinFormatMachO()) {
auto *PTy = cast<PointerType>(GEP->getType());
GlobalAlias::create(PTy, Linkage, Name, GEP, &M);
GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
Linkage, Name, GEP, &M);
}
NumMerged++;

3
llvm/lib/IR/Core.cpp
View File

@ -1644,7 +1644,8 @@ 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(GlobalAlias::create(PTy, GlobalValue::ExternalLinkage, Name,
return wrap(GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
GlobalValue::ExternalLinkage, Name,
unwrap<Constant>(Aliasee), unwrap(M)));
}

33
llvm/lib/IR/Globals.cpp
View File

@ -231,35 +231,40 @@ void GlobalVariable::copyAttributesFrom(const GlobalValue *Src) {
// GlobalAlias Implementation
//===----------------------------------------------------------------------===//
GlobalAlias::GlobalAlias(PointerType *Ty, LinkageTypes Link, const Twine &Name,
Constant *Aliasee, Module *ParentModule)
: GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name) {
GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
const Twine &Name, Constant *Aliasee,
Module *ParentModule)
: GlobalValue(PointerType::get(Ty, AddressSpace), Value::GlobalAliasVal,
&Op<0>(), 1, Link, Name) {
Op<0>() = Aliasee;
if (ParentModule)
ParentModule->getAliasList().push_back(this);
}
GlobalAlias *GlobalAlias::create(PointerType *Ty, LinkageTypes Link,
const Twine &Name, Constant *Aliasee,
Module *ParentModule) {
return new GlobalAlias(Ty, Link, Name, Aliasee, ParentModule);
GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
LinkageTypes Link, const Twine &Name,
Constant *Aliasee, Module *ParentModule) {
return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
}
GlobalAlias *GlobalAlias::create(PointerType *Ty, LinkageTypes Linkage,
const Twine &Name, Module *Parent) {
return create(Ty, Linkage, Name, nullptr, Parent);
GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
LinkageTypes Linkage, const Twine &Name,
Module *Parent) {
return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
}
GlobalAlias *GlobalAlias::create(PointerType *Ty, LinkageTypes Linkage,
const Twine &Name, GlobalValue *Aliasee) {
return create(Ty, Linkage, Name, Aliasee, Aliasee->getParent());
GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
LinkageTypes Linkage, const Twine &Name,
GlobalValue *Aliasee) {
return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
}
GlobalAlias *GlobalAlias::create(LinkageTypes Link, const Twine &Name,
GlobalValue *Aliasee) {
PointerType *PTy = Aliasee->getType();
return create(PTy, Link, Name, Aliasee);
return create(PTy->getElementType(), PTy->getAddressSpace(), Link, Name,
Aliasee);
}
GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalValue *Aliasee) {

3
llvm/lib/Linker/LinkModules.cpp
View File

@ -586,7 +586,8 @@ static GlobalAlias *copyGlobalAliasProto(TypeMapTy &TypeMap, Module &DstM,
// 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()));
return GlobalAlias::create(PTy, SGA->getLinkage(), SGA->getName(), &DstM);
return GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
SGA->getLinkage(), SGA->getName(), &DstM);
}
static GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM,

21
llvm/lib/Transforms/IPO/LowerBitSets.cpp
View File

@ -399,9 +399,8 @@ void LowerBitSets::allocateByteArrays() {
if (LinkerSubsectionsViaSymbols) {
BAI->ByteArray->replaceAllUsesWith(GEP);
} else {
GlobalAlias *Alias =
GlobalAlias::create(PointerType::getUnqual(Int8Ty),
GlobalValue::PrivateLinkage, "bits", GEP, M);
GlobalAlias *Alias = GlobalAlias::create(
Int8Ty, 0, GlobalValue::PrivateLinkage, "bits", GEP, M);
BAI->ByteArray->replaceAllUsesWith(Alias);
}
BAI->ByteArray->eraseFromParent();
@ -443,7 +442,7 @@ Value *LowerBitSets::createBitSetTest(IRBuilder<> &B, BitSetInfo &BSI,
// Each use of the byte array uses a different alias. This makes the
// backend less likely to reuse previously computed byte array addresses,
// improving the security of the CFI mechanism based on this pass.
ByteArray = GlobalAlias::create(BAI->ByteArray->getType(),
ByteArray = GlobalAlias::create(BAI->ByteArray->getValueType(), 0,
GlobalValue::PrivateLinkage, "bits_use",
ByteArray, M);
}
@ -581,9 +580,10 @@ void LowerBitSets::buildBitSetsFromGlobalVariables(
if (LinkerSubsectionsViaSymbols) {
Globals[I]->replaceAllUsesWith(CombinedGlobalElemPtr);
} else {
GlobalAlias *GAlias =
GlobalAlias::create(Globals[I]->getType(), Globals[I]->getLinkage(),
"", CombinedGlobalElemPtr, M);
GlobalAlias *GAlias = GlobalAlias::create(
Globals[I]->getType()->getElementType(),
Globals[I]->getType()->getAddressSpace(), Globals[I]->getLinkage(),
"", CombinedGlobalElemPtr, M);
GAlias->setVisibility(Globals[I]->getVisibility());
GAlias->takeName(Globals[I]);
Globals[I]->replaceAllUsesWith(GAlias);
@ -818,9 +818,10 @@ void LowerBitSets::buildBitSetsFromFunctions(ArrayRef<Metadata *> BitSets,
if (LinkerSubsectionsViaSymbols || Functions[I]->isDeclarationForLinker()) {
Functions[I]->replaceAllUsesWith(CombinedGlobalElemPtr);
} else {
GlobalAlias *GAlias = GlobalAlias::create(Functions[I]->getType(),
Functions[I]->getLinkage(), "",
CombinedGlobalElemPtr, M);
GlobalAlias *GAlias = GlobalAlias::create(
Functions[I]->getType()->getElementType(),
Functions[I]->getType()->getAddressSpace(),
Functions[I]->getLinkage(), "", CombinedGlobalElemPtr, M);
GAlias->setVisibility(Functions[I]->getVisibility());
GAlias->takeName(Functions[I]);
Functions[I]->replaceAllUsesWith(GAlias);

3
llvm/lib/Transforms/IPO/MergeFunctions.cpp
View File

@ -1683,7 +1683,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 = GlobalAlias::create(PTy, 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());

4
llvm/lib/Transforms/Utils/CloneModule.cpp
View File

@ -95,7 +95,9 @@ Module *llvm::CloneModule(
continue;
}
auto *PTy = cast<PointerType>(I->getType());
auto *GA = GlobalAlias::create(PTy, I->getLinkage(), I->getName(), New);
auto *GA =
GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
I->getLinkage(), I->getName(), New);
GA->copyAttributesFrom(I);
VMap[I] = GA;
}

4
llvm/unittests/IR/ConstantsTest.cpp
View File

@ -348,7 +348,7 @@ TEST(ConstantsTest, GEPReplaceWithConstant) {
std::unique_ptr<Module> M(new Module("MyModule", Context));
Type *IntTy = Type::getInt32Ty(Context);
auto *PtrTy = PointerType::get(IntTy, 0);
Type *PtrTy = PointerType::get(IntTy, 0);
auto *C1 = ConstantInt::get(IntTy, 1);
auto *Placeholder = new GlobalVariable(
*M, IntTy, false, GlobalValue::ExternalWeakLinkage, nullptr);
@ -361,7 +361,7 @@ TEST(ConstantsTest, GEPReplaceWithConstant) {
auto *Global = new GlobalVariable(*M, PtrTy, false,
GlobalValue::ExternalLinkage, nullptr);
auto *Alias = GlobalAlias::create(PtrTy, GlobalValue::ExternalLinkage,
auto *Alias = GlobalAlias::create(IntTy, 0, GlobalValue::ExternalLinkage,
"alias", Global, M.get());
Placeholder->replaceAllUsesWith(Alias);
ASSERT_EQ(GEP, Ref->getInitializer());