diff options
author | Rafael Espindola <rafael.espindola@gmail.com> | 2014-03-26 04:48:47 +0000 |
---|---|---|
committer | Rafael Espindola <rafael.espindola@gmail.com> | 2014-03-26 04:48:47 +0000 |
commit | 33845aa8c489e52e6287c75356daa8dd04b87350 (patch) | |
tree | bf3c0f7e8d86a434bbb77f630450b541239a1131 /lib/IR | |
parent | 577708be42f58f7f3042bbab50537ecdea20acad (diff) | |
download | llvm-33845aa8c489e52e6287c75356daa8dd04b87350.tar.gz llvm-33845aa8c489e52e6287c75356daa8dd04b87350.tar.bz2 llvm-33845aa8c489e52e6287c75356daa8dd04b87350.tar.xz |
Prevent alias from pointing to weak aliases.
Aliases are just another name for a position in a file. As such, the
regular symbol resolutions are not applied. For example, given
define void @my_func() {
ret void
}
@my_alias = alias weak void ()* @my_func
@my_alias2 = alias void ()* @my_alias
We produce without this patch:
.weak my_alias
my_alias = my_func
.globl my_alias2
my_alias2 = my_alias
That is, in the resulting ELF file my_alias, my_func and my_alias are
just 3 names pointing to offset 0 of .text. That is *not* the
semantics of IR linking. For example, linking in a
@my_alias = alias void ()* @other_func
would require the strong my_alias to override the weak one and
my_alias2 would end up pointing to other_func.
There is no way to represent that with aliases being just another
name, so the best solution seems to be to just disallow it, converting
a miscompile into an error.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@204781 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/IR')
-rw-r--r-- | lib/IR/Globals.cpp | 35 | ||||
-rw-r--r-- | lib/IR/Verifier.cpp | 10 |
2 files changed, 21 insertions, 24 deletions
diff --git a/lib/IR/Globals.cpp b/lib/IR/Globals.cpp index 11152d5d6c..f338dd76aa 100644 --- a/lib/IR/Globals.cpp +++ b/lib/IR/Globals.cpp @@ -236,10 +236,10 @@ void GlobalAlias::setAliasee(Constant *Aliasee) { setOperand(0, Aliasee); } -GlobalValue *GlobalAlias::getAliasedGlobal() { - Constant *C = getAliasee(); - if (C == 0) return 0; - +static GlobalValue *getAliaseeGV(GlobalAlias *GA) { + Constant *C = GA->getAliasee(); + assert(C && "Must alias something"); + if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) return GV; @@ -248,30 +248,23 @@ GlobalValue *GlobalAlias::getAliasedGlobal() { CE->getOpcode() == Instruction::AddrSpaceCast || CE->getOpcode() == Instruction::GetElementPtr) && "Unsupported aliasee"); - + return cast<GlobalValue>(CE->getOperand(0)); } -GlobalValue *GlobalAlias::resolveAliasedGlobal(bool stopOnWeak) { +GlobalValue *GlobalAlias::getAliasedGlobal() { SmallPtrSet<GlobalValue*, 3> Visited; - // Check if we need to stop early. - if (stopOnWeak && mayBeOverridden()) - return this; - - GlobalValue *GV = getAliasedGlobal(); - Visited.insert(GV); - - // Iterate over aliasing chain, stopping on weak alias if necessary. - while (GlobalAlias *GA = dyn_cast<GlobalAlias>(GV)) { - if (stopOnWeak && GA->mayBeOverridden()) - break; - - GV = GA->getAliasedGlobal(); + GlobalAlias *GA = this; + for (;;) { + GlobalValue *GV = getAliaseeGV(GA); if (!Visited.insert(GV)) return 0; - } - return GV; + // Iterate over aliasing chain. + GA = dyn_cast<GlobalAlias>(GV); + if (!GA) + return GV; + } } diff --git a/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp index 50c6ae204e..f5c8ac623b 100644 --- a/lib/IR/Verifier.cpp +++ b/lib/IR/Verifier.cpp @@ -502,10 +502,14 @@ void Verifier::visitGlobalAlias(const GlobalAlias &GA) { } } Assert1(!GV->isDeclaration(), "Alias must point to a definition", &GA); + if (const GlobalAlias *GAAliasee = dyn_cast<GlobalAlias>(GV)) { + Assert1(!GAAliasee->mayBeOverridden(), "Alias cannot point to a weak alias", + &GA); + } - const GlobalValue* Resolved = GA.resolveAliasedGlobal(/*stopOnWeak*/ false); - Assert1(Resolved, - "Aliasing chain should end with function or global variable", &GA); + const GlobalValue *AG = GA.getAliasedGlobal(); + Assert1(AG, "Aliasing chain should end with function or global variable", + &GA); visitGlobalValue(GA); } |