From 33845aa8c489e52e6287c75356daa8dd04b87350 Mon Sep 17 00:00:00 2001 From: Rafael Espindola Date: Wed, 26 Mar 2014 04:48:47 +0000 Subject: 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 --- docs/LangRef.rst | 4 +++ include/llvm/IR/GlobalAlias.h | 16 +++------- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 2 +- lib/ExecutionEngine/JIT/JITEmitter.cpp | 2 +- lib/IR/Globals.cpp | 35 +++++++++------------- lib/IR/Verifier.cpp | 10 +++++-- lib/Target/PowerPC/PPCAsmPrinter.cpp | 12 ++++---- lib/Target/PowerPC/PPCFastISel.cpp | 2 +- lib/Target/PowerPC/PPCISelDAGToDAG.cpp | 4 +-- lib/Target/TargetMachine.cpp | 2 +- lib/Target/X86/X86FastISel.cpp | 2 +- lib/Target/X86/X86ISelLowering.cpp | 2 +- lib/Target/XCore/XCoreISelLowering.cpp | 2 +- .../Instrumentation/DataFlowSanitizer.cpp | 3 +- test/CodeGen/X86/dllexport-x86_64.ll | 2 +- test/CodeGen/X86/dllexport.ll | 2 +- test/Feature/aliases.ll | 2 +- test/Transforms/GlobalOpt/alias-resolve.ll | 15 ++++++---- 18 files changed, 58 insertions(+), 61 deletions(-) diff --git a/docs/LangRef.rst b/docs/LangRef.rst index c959f56ef1..b0b8bfebee 100644 --- a/docs/LangRef.rst +++ b/docs/LangRef.rst @@ -681,6 +681,10 @@ the aliasee. The aliasee must be a definition. +Aliases are not allowed to point to aliases with linkages that can be +overridden. Since they are only a second name, the possibility of the +intermediate alias being overridden cannot be represented in an object file. + .. _namedmetadatastructure: Named Metadata diff --git a/include/llvm/IR/GlobalAlias.h b/include/llvm/IR/GlobalAlias.h index 81777af386..2ca481a515 100644 --- a/include/llvm/IR/GlobalAlias.h +++ b/include/llvm/IR/GlobalAlias.h @@ -64,23 +64,15 @@ public: Constant *getAliasee() { return getOperand(0); } - /// getAliasedGlobal() - Aliasee can be either global or bitcast of - /// global. This method retrives the global for both aliasee flavours. + + /// This method tries to ultimately resolve the alias by going through the + /// aliasing chain and trying to find the very last global. Returns NULL if a + /// cycle was found. GlobalValue *getAliasedGlobal(); const GlobalValue *getAliasedGlobal() const { return const_cast(this)->getAliasedGlobal(); } - /// resolveAliasedGlobal() - This method tries to ultimately resolve the alias - /// by going through the aliasing chain and trying to find the very last - /// global. Returns NULL if a cycle was found. If stopOnWeak is false, then - /// the whole chain aliasing chain is traversed, otherwise - only strong - /// aliases. - GlobalValue *resolveAliasedGlobal(bool stopOnWeak = true); - const GlobalValue *resolveAliasedGlobal(bool stopOnWeak = true) const { - return const_cast(this)->resolveAliasedGlobal(stopOnWeak); - } - static bool isValidLinkage(LinkageTypes L) { return isExternalLinkage(L) || isLocalLinkage(L) || isWeakLinkage(L) || isLinkOnceLinkage(L); diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index 61961d8ca2..52806235fd 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -1172,7 +1172,7 @@ SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, SDLoc DL, if (!GVar) { // If GV is an alias then use the aliasee for determining thread-localness. if (const GlobalAlias *GA = dyn_cast(GV)) - GVar = dyn_cast_or_null(GA->resolveAliasedGlobal(false)); + GVar = dyn_cast_or_null(GA->getAliasedGlobal()); } unsigned Opc; diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp index 4b2f012eaf..9d215ec96a 100644 --- a/lib/ExecutionEngine/JIT/JITEmitter.cpp +++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp @@ -688,7 +688,7 @@ void *JITEmitter::getPointerToGlobal(GlobalValue *V, void *Reference, return TheJIT->getOrEmitGlobalVariable(GV); if (GlobalAlias *GA = dyn_cast(V)) - return TheJIT->getPointerToGlobal(GA->resolveAliasedGlobal(false)); + return TheJIT->getPointerToGlobal(GA->getAliasedGlobal()); // If we have already compiled the function, return a pointer to its body. Function *F = cast(V); 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(C)) return GV; @@ -248,30 +248,23 @@ GlobalValue *GlobalAlias::getAliasedGlobal() { CE->getOpcode() == Instruction::AddrSpaceCast || CE->getOpcode() == Instruction::GetElementPtr) && "Unsupported aliasee"); - + return cast(CE->getOperand(0)); } -GlobalValue *GlobalAlias::resolveAliasedGlobal(bool stopOnWeak) { +GlobalValue *GlobalAlias::getAliasedGlobal() { SmallPtrSet 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(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(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(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); } diff --git a/lib/Target/PowerPC/PPCAsmPrinter.cpp b/lib/Target/PowerPC/PPCAsmPrinter.cpp index daf90c86ef..9ce8ea911c 100644 --- a/lib/Target/PowerPC/PPCAsmPrinter.cpp +++ b/lib/Target/PowerPC/PPCAsmPrinter.cpp @@ -381,8 +381,8 @@ void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) { if (MO.isGlobal()) { const GlobalValue *GValue = MO.getGlobal(); const GlobalAlias *GAlias = dyn_cast(GValue); - const GlobalValue *RealGValue = GAlias ? - GAlias->resolveAliasedGlobal(false) : GValue; + const GlobalValue *RealGValue = + GAlias ? GAlias->getAliasedGlobal() : GValue; MOSymbol = getSymbol(RealGValue); const GlobalVariable *GVar = dyn_cast(RealGValue); IsExternal = GVar && !GVar->hasInitializer(); @@ -428,8 +428,8 @@ void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) { else if (MO.isGlobal()) { const GlobalValue *GValue = MO.getGlobal(); const GlobalAlias *GAlias = dyn_cast(GValue); - const GlobalValue *RealGValue = GAlias ? - GAlias->resolveAliasedGlobal(false) : GValue; + const GlobalValue *RealGValue = + GAlias ? GAlias->getAliasedGlobal() : GValue; MOSymbol = getSymbol(RealGValue); const GlobalVariable *GVar = dyn_cast(RealGValue); @@ -463,8 +463,8 @@ void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) { if (MO.isGlobal()) { const GlobalValue *GValue = MO.getGlobal(); const GlobalAlias *GAlias = dyn_cast(GValue); - const GlobalValue *RealGValue = GAlias ? - GAlias->resolveAliasedGlobal(false) : GValue; + const GlobalValue *RealGValue = + GAlias ? GAlias->getAliasedGlobal() : GValue; MOSymbol = getSymbol(RealGValue); const GlobalVariable *GVar = dyn_cast(RealGValue); IsExternal = GVar && !GVar->hasInitializer(); diff --git a/lib/Target/PowerPC/PPCFastISel.cpp b/lib/Target/PowerPC/PPCFastISel.cpp index 4753160e09..dd45683032 100644 --- a/lib/Target/PowerPC/PPCFastISel.cpp +++ b/lib/Target/PowerPC/PPCFastISel.cpp @@ -1863,7 +1863,7 @@ unsigned PPCFastISel::PPCMaterializeGV(const GlobalValue *GV, MVT VT) { if (!GVar) { // If GV is an alias, use the aliasee for determining thread-locality. if (const GlobalAlias *GA = dyn_cast(GV)) - GVar = dyn_cast_or_null(GA->resolveAliasedGlobal(false)); + GVar = dyn_cast_or_null(GA->getAliasedGlobal()); } // FIXME: We don't yet handle the complexity of TLS. diff --git a/lib/Target/PowerPC/PPCISelDAGToDAG.cpp b/lib/Target/PowerPC/PPCISelDAGToDAG.cpp index 5b09588e0f..0e75bb4575 100644 --- a/lib/Target/PowerPC/PPCISelDAGToDAG.cpp +++ b/lib/Target/PowerPC/PPCISelDAGToDAG.cpp @@ -1413,8 +1413,8 @@ SDNode *PPCDAGToDAGISel::Select(SDNode *N) { if (GlobalAddressSDNode *G = dyn_cast(GA)) { const GlobalValue *GValue = G->getGlobal(); const GlobalAlias *GAlias = dyn_cast(GValue); - const GlobalValue *RealGValue = GAlias ? - GAlias->resolveAliasedGlobal(false) : GValue; + const GlobalValue *RealGValue = + GAlias ? GAlias->getAliasedGlobal() : GValue; const GlobalVariable *GVar = dyn_cast(RealGValue); assert((GVar || isa(RealGValue)) && "Unexpected global value subclass!"); diff --git a/lib/Target/TargetMachine.cpp b/lib/Target/TargetMachine.cpp index f8a58ec292..fe3c870c98 100644 --- a/lib/Target/TargetMachine.cpp +++ b/lib/Target/TargetMachine.cpp @@ -129,7 +129,7 @@ TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const { // If GV is an alias then use the aliasee for determining // thread-localness. if (const GlobalAlias *GA = dyn_cast(GV)) - GV = GA->resolveAliasedGlobal(false); + GV = GA->getAliasedGlobal(); const GlobalVariable *Var = cast(GV); bool isLocal = Var->hasLocalLinkage(); diff --git a/lib/Target/X86/X86FastISel.cpp b/lib/Target/X86/X86FastISel.cpp index c3e002082d..9c57f0d1f1 100644 --- a/lib/Target/X86/X86FastISel.cpp +++ b/lib/Target/X86/X86FastISel.cpp @@ -363,7 +363,7 @@ bool X86FastISel::handleConstantAddresses(const Value *V, X86AddressMode &AM) { // it works...). if (const GlobalAlias *GA = dyn_cast(GV)) if (const GlobalVariable *GVar = - dyn_cast_or_null(GA->resolveAliasedGlobal(false))) + dyn_cast_or_null(GA->getAliasedGlobal())) if (GVar->isThreadLocal()) return false; diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp index ec923ba7aa..630fba0151 100644 --- a/lib/Target/X86/X86ISelLowering.cpp +++ b/lib/Target/X86/X86ISelLowering.cpp @@ -8509,7 +8509,7 @@ X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const { // If GV is an alias then use the aliasee for determining // thread-localness. if (const GlobalAlias *GA = dyn_cast(GV)) - GV = GA->resolveAliasedGlobal(false); + GV = GA->getAliasedGlobal(); SDLoc dl(GA); SDValue Chain = DAG.getEntryNode(); diff --git a/lib/Target/XCore/XCoreISelLowering.cpp b/lib/Target/XCore/XCoreISelLowering.cpp index 079e886457..1b74013ac1 100644 --- a/lib/Target/XCore/XCoreISelLowering.cpp +++ b/lib/Target/XCore/XCoreISelLowering.cpp @@ -277,7 +277,7 @@ getGlobalAddressWrapper(SDValue GA, const GlobalValue *GV, const GlobalValue *UnderlyingGV = GV; // If GV is an alias then use the aliasee to determine the wrapper type if (const GlobalAlias *GA = dyn_cast(GV)) - UnderlyingGV = GA->resolveAliasedGlobal(); + UnderlyingGV = GA->getAliasedGlobal(); if (const GlobalVariable *GVar = dyn_cast(UnderlyingGV)) { if ( ( GVar->isConstant() && UnderlyingGV->isLocalLinkage(GV->getLinkage()) ) diff --git a/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp b/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp index 0249df1c6d..df1549d405 100644 --- a/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp +++ b/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp @@ -554,8 +554,7 @@ bool DataFlowSanitizer::runOnModule(Module &M) { ++i; // Don't stop on weak. We assume people aren't playing games with the // instrumentedness of overridden weak aliases. - if (Function *F = dyn_cast( - GA->resolveAliasedGlobal(/*stopOnWeak=*/false))) { + if (Function *F = dyn_cast(GA->getAliasedGlobal())) { bool GAInst = isInstrumented(GA), FInst = isInstrumented(F); if (GAInst && FInst) { addGlobalNamePrefix(GA); diff --git a/test/CodeGen/X86/dllexport-x86_64.ll b/test/CodeGen/X86/dllexport-x86_64.ll index 1fadfec254..a38c2d8f8a 100644 --- a/test/CodeGen/X86/dllexport-x86_64.ll +++ b/test/CodeGen/X86/dllexport-x86_64.ll @@ -65,7 +65,7 @@ define weak_odr dllexport void @weak1() { @alias2 = dllexport alias void()* @f1 ; CHECK: .globl alias3 -; CHECK: alias3 = alias +; CHECK: alias3 = notExported @alias3 = dllexport alias void()* @alias ; CHECK: .weak weak_alias diff --git a/test/CodeGen/X86/dllexport.ll b/test/CodeGen/X86/dllexport.ll index 7f0dadb6a2..1b34d23869 100644 --- a/test/CodeGen/X86/dllexport.ll +++ b/test/CodeGen/X86/dllexport.ll @@ -80,7 +80,7 @@ define weak_odr dllexport void @weak1() { @alias2 = dllexport alias void()* @f1 ; CHECK: .globl _alias3 -; CHECK: _alias3 = _alias +; CHECK: _alias3 = _notExported @alias3 = dllexport alias void()* @alias ; CHECK: .weak _weak_alias diff --git a/test/Feature/aliases.ll b/test/Feature/aliases.ll index 7ffa5f2601..7fe9d0b374 100644 --- a/test/Feature/aliases.ll +++ b/test/Feature/aliases.ll @@ -14,7 +14,7 @@ define i32 @foo_f() { ret i32 0 } -@bar_f = alias weak %FunTy* @foo_f +@bar_f = alias weak_odr %FunTy* @foo_f @bar_ff = alias i32()* @bar_f @bar_i = alias internal i32* @bar diff --git a/test/Transforms/GlobalOpt/alias-resolve.ll b/test/Transforms/GlobalOpt/alias-resolve.ll index 64e3d88af8..2d5a956d14 100644 --- a/test/Transforms/GlobalOpt/alias-resolve.ll +++ b/test/Transforms/GlobalOpt/alias-resolve.ll @@ -1,14 +1,17 @@ ; RUN: opt < %s -globalopt -S | FileCheck %s @foo1 = alias void ()* @foo2 -; CHECK: @foo1 = alias void ()* @foo2 +; CHECK: @foo1 = alias void ()* @bar2 -@foo2 = alias weak void()* @bar1 -; CHECK: @foo2 = alias weak void ()* @bar2 +@foo2 = alias void()* @bar1 +; CHECK: @foo2 = alias void ()* @bar2 @bar1 = alias void ()* @bar2 ; CHECK: @bar1 = alias void ()* @bar2 +@weak1 = alias weak void ()* @bar2 +; CHECK: @weak1 = alias weak void ()* @bar2 + define void @bar2() { ret void } @@ -17,14 +20,16 @@ define void @bar2() { define void @baz() { entry: call void @foo1() -; CHECK: call void @foo2() +; CHECK: call void @bar2() call void @foo2() -; CHECK: call void @foo2() +; CHECK: call void @bar2() call void @bar1() ; CHECK: call void @bar2() + call void @weak1() +; CHECK: call void @weak1() ret void } -- cgit v1.2.3