[llvm-commits] [llvm] r126830 - in /llvm/trunk: include/llvm/Module.h lib/AsmParser/LLParser.cpp lib/VMCore/AsmWriter.cpp tools/lto/LTOCodeGenerator.cpp tools/lto/LTOCodeGenerator.h tools/lto/LTOModule.cpp tools/lto/LTOModule.h
Rafael Espindola
rafael.espindola at gmail.com
Tue Mar 1 20:14:42 PST 2011
Author: rafael
Date: Tue Mar 1 22:14:42 2011
New Revision: 126830
URL: http://llvm.org/viewvc/llvm-project?rev=126830&view=rev
Log:
Add a special streamer to libLTO that just records symbols definitions and
uses.
The result produced by the streamer is used to give the linker more accurate
information and to add to llvm.compiler.used. The second improvement removes
the need for the user to add __attribute__((used)) to functions only used in
inline asm. The first one lets us build firefox with LTO on Darwin :-)
Modified:
llvm/trunk/include/llvm/Module.h
llvm/trunk/lib/AsmParser/LLParser.cpp
llvm/trunk/lib/VMCore/AsmWriter.cpp
llvm/trunk/tools/lto/LTOCodeGenerator.cpp
llvm/trunk/tools/lto/LTOCodeGenerator.h
llvm/trunk/tools/lto/LTOModule.cpp
llvm/trunk/tools/lto/LTOModule.h
Modified: llvm/trunk/include/llvm/Module.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Module.h?rev=126830&r1=126829&r2=126830&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Module.h (original)
+++ llvm/trunk/include/llvm/Module.h Tue Mar 1 22:14:42 2011
@@ -211,15 +211,20 @@
void setTargetTriple(StringRef T) { TargetTriple = T; }
/// Set the module-scope inline assembly blocks.
- void setModuleInlineAsm(StringRef Asm) { GlobalScopeAsm = Asm; }
+ void setModuleInlineAsm(StringRef Asm) {
+ GlobalScopeAsm = Asm;
+ if (!GlobalScopeAsm.empty() &&
+ GlobalScopeAsm[GlobalScopeAsm.size()-1] != '\n')
+ GlobalScopeAsm += '\n';
+ }
/// Append to the module-scope inline assembly blocks, automatically inserting
/// a separating newline if necessary.
void appendModuleInlineAsm(StringRef Asm) {
+ GlobalScopeAsm += Asm;
if (!GlobalScopeAsm.empty() &&
GlobalScopeAsm[GlobalScopeAsm.size()-1] != '\n')
GlobalScopeAsm += '\n';
- GlobalScopeAsm += Asm;
}
/// @}
Modified: llvm/trunk/lib/AsmParser/LLParser.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/AsmParser/LLParser.cpp?rev=126830&r1=126829&r2=126830&view=diff
==============================================================================
--- llvm/trunk/lib/AsmParser/LLParser.cpp (original)
+++ llvm/trunk/lib/AsmParser/LLParser.cpp Tue Mar 1 22:14:42 2011
@@ -249,11 +249,7 @@
if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
ParseStringConstant(AsmStr)) return true;
- const std::string &AsmSoFar = M->getModuleInlineAsm();
- if (AsmSoFar.empty())
- M->setModuleInlineAsm(AsmStr);
- else
- M->setModuleInlineAsm(AsmSoFar+"\n"+AsmStr);
+ M->appendModuleInlineAsm(AsmStr);
return false;
}
Modified: llvm/trunk/lib/VMCore/AsmWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/AsmWriter.cpp?rev=126830&r1=126829&r2=126830&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/AsmWriter.cpp (original)
+++ llvm/trunk/lib/VMCore/AsmWriter.cpp Tue Mar 1 22:14:42 2011
@@ -1338,9 +1338,12 @@
CurPos = NewLine+1;
NewLine = Asm.find_first_of('\n', CurPos);
}
- Out << "module asm \"";
- PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out);
- Out << "\"\n";
+ std::string rest(Asm.begin()+CurPos, Asm.end());
+ if (!rest.empty()) {
+ Out << "module asm \"";
+ PrintEscapedString(rest, Out);
+ Out << "\"\n";
+ }
}
// Loop over the dependent libraries and emit them.
Modified: llvm/trunk/tools/lto/LTOCodeGenerator.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lto/LTOCodeGenerator.cpp?rev=126830&r1=126829&r2=126830&view=diff
==============================================================================
--- llvm/trunk/tools/lto/LTOCodeGenerator.cpp (original)
+++ llvm/trunk/tools/lto/LTOCodeGenerator.cpp Tue Mar 1 22:14:42 2011
@@ -75,7 +75,6 @@
{
InitializeAllTargets();
InitializeAllAsmPrinters();
- InitializeAllAsmParsers();
}
LTOCodeGenerator::~LTOCodeGenerator()
@@ -88,7 +87,13 @@
bool LTOCodeGenerator::addModule(LTOModule* mod, std::string& errMsg)
{
- return _linker.LinkInModule(mod->getLLVVMModule(), &errMsg);
+ bool ret = _linker.LinkInModule(mod->getLLVVMModule(), &errMsg);
+
+ const std::vector<const char*> &undefs = mod->getAsmUndefinedRefs();
+ for (int i = 0, e = undefs.size(); i != e; ++i)
+ _asmUndefinedRefs[undefs[i]] = 1;
+
+ return ret;
}
@@ -249,6 +254,34 @@
return false;
}
+void LTOCodeGenerator::applyRestriction(GlobalValue &GV,
+ std::vector<const char*> &mustPreserveList,
+ SmallPtrSet<GlobalValue*, 8> &asmUsed,
+ Mangler &mangler) {
+ SmallString<64> Buffer;
+ mangler.getNameWithPrefix(Buffer, &GV, false);
+
+ if (GV.isDeclaration())
+ return;
+ if (_mustPreserveSymbols.count(Buffer))
+ mustPreserveList.push_back(GV.getName().data());
+ if (_asmUndefinedRefs.count(Buffer))
+ asmUsed.insert(&GV);
+}
+
+static void findUsedValues(GlobalVariable *LLVMUsed,
+ SmallPtrSet<GlobalValue*, 8> &UsedValues) {
+ if (LLVMUsed == 0) return;
+
+ ConstantArray *Inits = dyn_cast<ConstantArray>(LLVMUsed->getInitializer());
+ if (Inits == 0) return;
+
+ for (unsigned i = 0, e = Inits->getNumOperands(); i != e; ++i)
+ if (GlobalValue *GV =
+ dyn_cast<GlobalValue>(Inits->getOperand(i)->stripPointerCasts()))
+ UsedValues.insert(GV);
+}
+
void LTOCodeGenerator::applyScopeRestrictions() {
if (_scopeRestrictionsDone) return;
Module *mergedModule = _linker.getModule();
@@ -258,38 +291,47 @@
passes.add(createVerifierPass());
// mark which symbols can not be internalized
- if (!_mustPreserveSymbols.empty()) {
- MCContext Context(*_target->getMCAsmInfo(), NULL);
- Mangler mangler(Context, *_target->getTargetData());
- std::vector<const char*> mustPreserveList;
- SmallString<64> Buffer;
- for (Module::iterator f = mergedModule->begin(),
- e = mergedModule->end(); f != e; ++f) {
- Buffer.clear();
- mangler.getNameWithPrefix(Buffer, f, false);
- if (!f->isDeclaration() &&
- _mustPreserveSymbols.count(Buffer))
- mustPreserveList.push_back(f->getName().data());
- }
- for (Module::global_iterator v = mergedModule->global_begin(),
- e = mergedModule->global_end(); v != e; ++v) {
- Buffer.clear();
- mangler.getNameWithPrefix(Buffer, v, false);
- if (!v->isDeclaration() &&
- _mustPreserveSymbols.count(Buffer))
- mustPreserveList.push_back(v->getName().data());
- }
- for (Module::alias_iterator a = mergedModule->alias_begin(),
- e = mergedModule->alias_end(); a != e; ++a) {
- Buffer.clear();
- mangler.getNameWithPrefix(Buffer, a, false);
- if (!a->isDeclaration() &&
- _mustPreserveSymbols.count(Buffer))
- mustPreserveList.push_back(a->getName().data());
- }
- passes.add(createInternalizePass(mustPreserveList));
+ MCContext Context(*_target->getMCAsmInfo(), NULL);
+ Mangler mangler(Context, *_target->getTargetData());
+ std::vector<const char*> mustPreserveList;
+ SmallPtrSet<GlobalValue*, 8> asmUsed;
+
+ for (Module::iterator f = mergedModule->begin(),
+ e = mergedModule->end(); f != e; ++f)
+ applyRestriction(*f, mustPreserveList, asmUsed, mangler);
+ for (Module::global_iterator v = mergedModule->global_begin(),
+ e = mergedModule->global_end(); v != e; ++v)
+ applyRestriction(*v, mustPreserveList, asmUsed, mangler);
+ for (Module::alias_iterator a = mergedModule->alias_begin(),
+ e = mergedModule->alias_end(); a != e; ++a)
+ applyRestriction(*a, mustPreserveList, asmUsed, mangler);
+
+ GlobalVariable *LLVMCompilerUsed =
+ mergedModule->getGlobalVariable("llvm.compiler.used");
+ findUsedValues(LLVMCompilerUsed, asmUsed);
+ if (LLVMCompilerUsed)
+ LLVMCompilerUsed->eraseFromParent();
+
+ const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(_context);
+ std::vector<Constant*> asmUsed2;
+ for (SmallPtrSet<GlobalValue*, 16>::const_iterator i = asmUsed.begin(),
+ e = asmUsed.end(); i !=e; ++i) {
+ GlobalValue *GV = *i;
+ Constant *c = ConstantExpr::getBitCast(GV, i8PTy);
+ asmUsed2.push_back(c);
}
-
+
+ llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, asmUsed2.size());
+ LLVMCompilerUsed =
+ new llvm::GlobalVariable(*mergedModule, ATy, false,
+ llvm::GlobalValue::AppendingLinkage,
+ llvm::ConstantArray::get(ATy, asmUsed2),
+ "llvm.compiler.used");
+
+ LLVMCompilerUsed->setSection("llvm.metadata");
+
+ passes.add(createInternalizePass(mustPreserveList));
+
// apply scope restrictions
passes.run(*mergedModule);
Modified: llvm/trunk/tools/lto/LTOCodeGenerator.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lto/LTOCodeGenerator.h?rev=126830&r1=126829&r2=126830&view=diff
==============================================================================
--- llvm/trunk/tools/lto/LTOCodeGenerator.h (original)
+++ llvm/trunk/tools/lto/LTOCodeGenerator.h Tue Mar 1 22:14:42 2011
@@ -19,6 +19,7 @@
#include "llvm/LLVMContext.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
#include <string>
@@ -46,6 +47,10 @@
bool generateObjectFile(llvm::raw_ostream& out,
std::string& errMsg);
void applyScopeRestrictions();
+ void applyRestriction(llvm::GlobalValue &GV,
+ std::vector<const char*> &mustPreserveList,
+ llvm::SmallPtrSet<llvm::GlobalValue*, 8> &asmUsed,
+ llvm::Mangler &mangler);
bool determineTarget(std::string& errMsg);
typedef llvm::StringMap<uint8_t> StringSet;
@@ -57,6 +62,7 @@
bool _scopeRestrictionsDone;
lto_codegen_model _codeModel;
StringSet _mustPreserveSymbols;
+ StringSet _asmUndefinedRefs;
llvm::MemoryBuffer* _nativeObjectFile;
std::vector<const char*> _codegenOptions;
std::string _mCpu;
Modified: llvm/trunk/tools/lto/LTOModule.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lto/LTOModule.cpp?rev=126830&r1=126829&r2=126830&view=diff
==============================================================================
--- llvm/trunk/tools/lto/LTOModule.cpp (original)
+++ llvm/trunk/tools/lto/LTOModule.cpp Tue Mar 1 22:14:42 2011
@@ -26,11 +26,18 @@
#include "llvm/Support/Host.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Process.h"
+#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/system_error.h"
#include "llvm/Target/Mangler.h"
#include "llvm/Target/SubtargetFeature.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCParser/MCAsmParser.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbol.h"
+#include "llvm/Target/TargetAsmParser.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Target/TargetSelect.h"
@@ -73,7 +80,7 @@
LTOModule::LTOModule(Module *m, TargetMachine *t)
- : _module(m), _target(t), _symbolsParsed(false)
+ : _module(m), _target(t)
{
}
@@ -123,7 +130,12 @@
LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer,
std::string &errMsg) {
- InitializeAllTargets();
+ static bool Initialized = false;
+ if (!Initialized) {
+ InitializeAllTargets();
+ InitializeAllAsmParsers();
+ Initialized = true;
+ }
// parse bitcode buffer
OwningPtr<Module> m(ParseBitcodeFile(buffer, getGlobalContext(), &errMsg));
@@ -144,7 +156,13 @@
Features.getDefaultSubtargetFeatures("" /* cpu */, llvm::Triple(Triple));
std::string FeatureStr = Features.getString();
TargetMachine *target = march->createTargetMachine(Triple, FeatureStr);
- return new LTOModule(m.take(), target);
+ LTOModule *Ret = new LTOModule(m.take(), target);
+ bool Err = Ret->ParseSymbols();
+ if (Err) {
+ delete Ret;
+ return NULL;
+ }
+ return Ret;
}
@@ -383,7 +401,8 @@
_symbols.push_back(info);
}
-void LTOModule::addAsmGlobalSymbol(const char *name) {
+void LTOModule::addAsmGlobalSymbol(const char *name,
+ lto_symbol_attributes scope) {
StringSet::value_type &entry = _defines.GetOrCreateValue(name);
// only add new define if not already defined
@@ -393,13 +412,32 @@
entry.setValue(1);
const char *symbolName = entry.getKey().data();
uint32_t attr = LTO_SYMBOL_DEFINITION_REGULAR;
- attr |= LTO_SYMBOL_SCOPE_DEFAULT;
+ attr |= scope;
NameAndAttributes info;
info.name = symbolName;
info.attributes = (lto_symbol_attributes)attr;
_symbols.push_back(info);
}
+void LTOModule::addAsmGlobalSymbolUndef(const char *name) {
+ StringMap<NameAndAttributes>::value_type &entry =
+ _undefines.GetOrCreateValue(name);
+
+ _asm_undefines.push_back(entry.getKey().data());
+
+ // we already have the symbol
+ if (entry.getValue().name)
+ return;
+
+ uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED;;
+ attr |= LTO_SYMBOL_SCOPE_DEFAULT;
+ NameAndAttributes info;
+ info.name = entry.getKey().data();
+ info.attributes = (lto_symbol_attributes)attr;
+
+ entry.setValue(info);
+}
+
void LTOModule::addPotentialUndefinedSymbol(GlobalValue *decl,
Mangler &mangler) {
// ignore all llvm.* symbols
@@ -454,12 +492,194 @@
}
}
-void LTOModule::lazyParseSymbols() {
- if (_symbolsParsed)
- return;
+namespace {
+ class RecordStreamer : public MCStreamer {
+ public:
+ enum State { NeverSeen, Global, Defined, DefinedGlobal, Used};
+
+ private:
+ StringMap<State> Symbols;
+
+ void markDefined(const MCSymbol &Symbol) {
+ State &S = Symbols[Symbol.getName()];
+ switch (S) {
+ case DefinedGlobal:
+ case Global:
+ S = DefinedGlobal;
+ break;
+ case NeverSeen:
+ case Defined:
+ case Used:
+ S = Defined;
+ break;
+ }
+ }
+ void markGlobal(const MCSymbol &Symbol) {
+ State &S = Symbols[Symbol.getName()];
+ switch (S) {
+ case DefinedGlobal:
+ case Defined:
+ S = DefinedGlobal;
+ break;
+
+ case NeverSeen:
+ case Global:
+ case Used:
+ S = Global;
+ break;
+ }
+ }
+ void markUsed(const MCSymbol &Symbol) {
+ State &S = Symbols[Symbol.getName()];
+ switch (S) {
+ case DefinedGlobal:
+ case Defined:
+ case Global:
+ break;
+
+ case NeverSeen:
+ case Used:
+ S = Used;
+ break;
+ }
+ }
- _symbolsParsed = true;
+ // FIXME: mostly copied for the obj streamer.
+ void AddValueSymbols(const MCExpr *Value) {
+ switch (Value->getKind()) {
+ case MCExpr::Target:
+ // FIXME: What should we do in here?
+ break;
+
+ case MCExpr::Constant:
+ break;
+
+ case MCExpr::Binary: {
+ const MCBinaryExpr *BE = cast<MCBinaryExpr>(Value);
+ AddValueSymbols(BE->getLHS());
+ AddValueSymbols(BE->getRHS());
+ break;
+ }
+ case MCExpr::SymbolRef:
+ markUsed(cast<MCSymbolRefExpr>(Value)->getSymbol());
+ break;
+
+ case MCExpr::Unary:
+ AddValueSymbols(cast<MCUnaryExpr>(Value)->getSubExpr());
+ break;
+ }
+ }
+
+ public:
+ typedef StringMap<State>::const_iterator const_iterator;
+
+ const_iterator begin() {
+ return Symbols.begin();
+ }
+
+ const_iterator end() {
+ return Symbols.end();
+ }
+
+ RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
+
+ virtual void ChangeSection(const MCSection *Section) {}
+ virtual void InitSections() {}
+ virtual void EmitLabel(MCSymbol *Symbol) {
+ Symbol->setSection(*getCurrentSection());
+ markDefined(*Symbol);
+ }
+ virtual void EmitAssemblerFlag(MCAssemblerFlag Flag) {}
+ virtual void EmitThumbFunc(MCSymbol *Func) {}
+ virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
+ // FIXME: should we handle aliases?
+ markDefined(*Symbol);
+ }
+ virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) {
+ if (Attribute == MCSA_Global)
+ markGlobal(*Symbol);
+ }
+ virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
+ virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
+ virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) {}
+ virtual void EmitCOFFSymbolStorageClass(int StorageClass) {}
+ virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
+ unsigned Size , unsigned ByteAlignment) {
+ markDefined(*Symbol);
+ }
+ virtual void EmitCOFFSymbolType(int Type) {}
+ virtual void EndCOFFSymbolDef() {}
+ virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ unsigned ByteAlignment) {
+ markDefined(*Symbol);
+ }
+ virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
+ virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) {}
+ virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
+ uint64_t Size, unsigned ByteAlignment) {}
+ virtual void EmitBytes(StringRef Data, unsigned AddrSpace) {}
+ virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
+ bool isPCRel, unsigned AddrSpace) {}
+ virtual void EmitULEB128Value(const MCExpr *Value,
+ unsigned AddrSpace = 0) {}
+ virtual void EmitSLEB128Value(const MCExpr *Value,
+ unsigned AddrSpace = 0) {}
+ virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
+ unsigned ValueSize,
+ unsigned MaxBytesToEmit) {}
+ virtual void EmitCodeAlignment(unsigned ByteAlignment,
+ unsigned MaxBytesToEmit) {}
+ virtual void EmitValueToOffset(const MCExpr *Offset,
+ unsigned char Value ) {}
+ virtual void EmitFileDirective(StringRef Filename) {}
+ virtual void EmitDwarfAdvanceLineAddr(int64_t LineDelta,
+ const MCSymbol *LastLabel,
+ const MCSymbol *Label) {}
+
+ virtual void EmitInstruction(const MCInst &Inst) {
+ // Scan for values.
+ for (unsigned i = Inst.getNumOperands(); i--; )
+ if (Inst.getOperand(i).isExpr())
+ AddValueSymbols(Inst.getOperand(i).getExpr());
+ }
+ virtual void Finish() {}
+ };
+}
+
+bool LTOModule::addAsmGlobalSymbols(MCContext &Context) {
+ const std::string &inlineAsm = _module->getModuleInlineAsm();
+
+ OwningPtr<RecordStreamer> Streamer(new RecordStreamer(Context));
+ MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(inlineAsm);
+ SourceMgr SrcMgr;
+ SrcMgr.AddNewSourceBuffer(Buffer, SMLoc());
+ OwningPtr<MCAsmParser> Parser(createMCAsmParser(_target->getTarget(), SrcMgr,
+ Context, *Streamer,
+ *_target->getMCAsmInfo()));
+ OwningPtr<TargetAsmParser>
+ TAP(_target->getTarget().createAsmParser(*Parser.get(), *_target.get()));
+ Parser->setTargetParser(*TAP);
+ int Res = Parser->Run(false);
+ if (Res)
+ return true;
+
+ for (RecordStreamer::const_iterator i = Streamer->begin(),
+ e = Streamer->end(); i != e; ++i) {
+ StringRef Key = i->first();
+ RecordStreamer::State Value = i->second;
+ if (Value == RecordStreamer::DefinedGlobal)
+ addAsmGlobalSymbol(Key.data(), LTO_SYMBOL_SCOPE_DEFAULT);
+ else if (Value == RecordStreamer::Defined)
+ addAsmGlobalSymbol(Key.data(), LTO_SYMBOL_SCOPE_INTERNAL);
+ else if (Value == RecordStreamer::Global ||
+ Value == RecordStreamer::Used)
+ addAsmGlobalSymbolUndef(Key.data());
+ }
+ return false;
+}
+
+bool LTOModule::ParseSymbols() {
// Use mangler to add GlobalPrefix to names to match linker names.
MCContext Context(*_target->getMCAsmInfo(), NULL);
Mangler mangler(Context, *_target->getTargetData());
@@ -482,30 +702,8 @@
}
// add asm globals
- const std::string &inlineAsm = _module->getModuleInlineAsm();
- const std::string glbl = ".globl";
- std::string asmSymbolName;
- std::string::size_type pos = inlineAsm.find(glbl, 0);
- while (pos != std::string::npos) {
- // eat .globl
- pos = pos + 6;
-
- // skip white space between .globl and symbol name
- std::string::size_type pbegin = inlineAsm.find_first_not_of(' ', pos);
- if (pbegin == std::string::npos)
- break;
-
- // find end-of-line
- std::string::size_type pend = inlineAsm.find_first_of('\n', pbegin);
- if (pend == std::string::npos)
- break;
-
- asmSymbolName.assign(inlineAsm, pbegin, pend - pbegin);
- addAsmGlobalSymbol(asmSymbolName.c_str());
-
- // search next .globl
- pos = inlineAsm.find(glbl, pend);
- }
+ if (addAsmGlobalSymbols(Context))
+ return true;
// add aliases
for (Module::alias_iterator i = _module->alias_begin(),
@@ -526,17 +724,16 @@
_symbols.push_back(info);
}
}
+ return false;
}
uint32_t LTOModule::getSymbolCount() {
- lazyParseSymbols();
return _symbols.size();
}
lto_symbol_attributes LTOModule::getSymbolAttributes(uint32_t index) {
- lazyParseSymbols();
if (index < _symbols.size())
return _symbols[index].attributes;
else
@@ -544,7 +741,6 @@
}
const char *LTOModule::getSymbolName(uint32_t index) {
- lazyParseSymbols();
if (index < _symbols.size())
return _symbols[index].name;
else
Modified: llvm/trunk/tools/lto/LTOModule.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lto/LTOModule.h?rev=126830&r1=126829&r2=126830&view=diff
==============================================================================
--- llvm/trunk/tools/lto/LTOModule.h (original)
+++ llvm/trunk/tools/lto/LTOModule.h Tue Mar 1 22:14:42 2011
@@ -64,11 +64,14 @@
const char* getSymbolName(uint32_t index);
llvm::Module * getLLVVMModule() { return _module.get(); }
+ const std::vector<const char*> &getAsmUndefinedRefs() {
+ return _asm_undefines;
+ }
private:
LTOModule(llvm::Module* m, llvm::TargetMachine* t);
- void lazyParseSymbols();
+ bool ParseSymbols();
void addDefinedSymbol(llvm::GlobalValue* def,
llvm::Mangler& mangler,
bool isFunction);
@@ -80,7 +83,10 @@
llvm::Mangler &mangler);
void addDefinedDataSymbol(llvm::GlobalValue* v,
llvm::Mangler &mangler);
- void addAsmGlobalSymbol(const char *);
+ bool addAsmGlobalSymbols(llvm::MCContext &Context);
+ void addAsmGlobalSymbol(const char *,
+ lto_symbol_attributes scope);
+ void addAsmGlobalSymbolUndef(const char *);
void addObjCClass(llvm::GlobalVariable* clgv);
void addObjCCategory(llvm::GlobalVariable* clgv);
void addObjCClassRef(llvm::GlobalVariable* clgv);
@@ -103,11 +109,11 @@
llvm::OwningPtr<llvm::Module> _module;
llvm::OwningPtr<llvm::TargetMachine> _target;
- bool _symbolsParsed;
std::vector<NameAndAttributes> _symbols;
// _defines and _undefines only needed to disambiguate tentative definitions
StringSet _defines;
llvm::StringMap<NameAndAttributes> _undefines;
+ std::vector<const char*> _asm_undefines;
};
#endif // LTO_MODULE_H
More information about the llvm-commits
mailing list