66dc0905951adaba05a402b94003e6b376bd7e76
[oota-llvm.git] / tools / lto / LTOModule.cpp
1 //===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Link Time Optimization library. This library is
11 // intended to be used by linker to optimize code at link time.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "LTOModule.h"
16
17 #include "llvm/Constants.h"
18 #include "llvm/LLVMContext.h"
19 #include "llvm/Module.h"
20 #include "llvm/ADT/OwningPtr.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/Bitcode/ReaderWriter.h"
23 #include "llvm/Support/SystemUtils.h"
24 #include "llvm/Support/MemoryBuffer.h"
25 #include "llvm/Support/MathExtras.h"
26 #include "llvm/Support/Host.h"
27 #include "llvm/Support/Path.h"
28 #include "llvm/Support/Process.h"
29 #include "llvm/Support/SourceMgr.h"
30 #include "llvm/Support/TargetRegistry.h"
31 #include "llvm/Support/TargetSelect.h"
32 #include "llvm/Support/system_error.h"
33 #include "llvm/MC/MCAsmInfo.h"
34 #include "llvm/MC/MCExpr.h"
35 #include "llvm/MC/MCInst.h"
36 #include "llvm/MC/MCParser/MCAsmParser.h"
37 #include "llvm/MC/MCStreamer.h"
38 #include "llvm/MC/MCSubtargetInfo.h"
39 #include "llvm/MC/MCSymbol.h"
40 #include "llvm/MC/SubtargetFeature.h"
41 #include "llvm/MC/MCTargetAsmParser.h"
42 #include "llvm/Target/TargetMachine.h"
43 #include "llvm/Target/TargetRegisterInfo.h"
44
45 using namespace llvm;
46
47 bool LTOModule::isBitcodeFile(const void *mem, size_t length) {
48   return llvm::sys::IdentifyFileType((char*)mem, length)
49     == llvm::sys::Bitcode_FileType;
50 }
51
52 bool LTOModule::isBitcodeFile(const char *path) {
53   return llvm::sys::Path(path).isBitcodeFile();
54 }
55
56 bool LTOModule::isBitcodeFileForTarget(const void *mem, size_t length,
57                                        const char *triplePrefix) {
58   MemoryBuffer *buffer = makeBuffer(mem, length);
59   if (!buffer)
60     return false;
61   return isTargetMatch(buffer, triplePrefix);
62 }
63
64
65 bool LTOModule::isBitcodeFileForTarget(const char *path,
66                                        const char *triplePrefix) {
67   OwningPtr<MemoryBuffer> buffer;
68   if (MemoryBuffer::getFile(path, buffer))
69     return false;
70   return isTargetMatch(buffer.take(), triplePrefix);
71 }
72
73 // Takes ownership of buffer.
74 bool LTOModule::isTargetMatch(MemoryBuffer *buffer, const char *triplePrefix) {
75   std::string Triple = getBitcodeTargetTriple(buffer, getGlobalContext());
76   delete buffer;
77   return (strncmp(Triple.c_str(), triplePrefix,
78                   strlen(triplePrefix)) == 0);
79 }
80
81
82 LTOModule::LTOModule(Module *m, TargetMachine *t)
83   : _module(m), _target(t),
84     _context(*_target->getMCAsmInfo(), *_target->getRegisterInfo(), NULL),
85     _mangler(_context, *_target->getTargetData())
86 {
87 }
88
89 LTOModule *LTOModule::makeLTOModule(const char *path,
90                                     std::string &errMsg) {
91   OwningPtr<MemoryBuffer> buffer;
92   if (error_code ec = MemoryBuffer::getFile(path, buffer)) {
93     errMsg = ec.message();
94     return NULL;
95   }
96   return makeLTOModule(buffer.take(), errMsg);
97 }
98
99 LTOModule *LTOModule::makeLTOModule(int fd, const char *path,
100                                     size_t size,
101                                     std::string &errMsg) {
102   return makeLTOModule(fd, path, size, size, 0, errMsg);
103 }
104
105 LTOModule *LTOModule::makeLTOModule(int fd, const char *path,
106                                     size_t file_size,
107                                     size_t map_size,
108                                     off_t offset,
109                                     std::string &errMsg) {
110   OwningPtr<MemoryBuffer> buffer;
111   if (error_code ec = MemoryBuffer::getOpenFile(fd, path, buffer, file_size,
112                                                 map_size, offset, false)) {
113     errMsg = ec.message();
114     return NULL;
115   }
116   return makeLTOModule(buffer.take(), errMsg);
117 }
118
119 /// makeBuffer - Create a MemoryBuffer from a memory range.
120 MemoryBuffer *LTOModule::makeBuffer(const void *mem, size_t length) {
121   const char *startPtr = (char*)mem;
122   return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), "", false);
123 }
124
125
126 LTOModule *LTOModule::makeLTOModule(const void *mem, size_t length,
127                                     std::string &errMsg) {
128   OwningPtr<MemoryBuffer> buffer(makeBuffer(mem, length));
129   if (!buffer)
130     return NULL;
131   return makeLTOModule(buffer.take(), errMsg);
132 }
133
134 LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer,
135                                     std::string &errMsg) {
136   static bool Initialized = false;
137   if (!Initialized) {
138     InitializeAllTargets();
139     InitializeAllTargetMCs();
140     InitializeAllAsmParsers();
141     Initialized = true;
142   }
143
144   // parse bitcode buffer
145   OwningPtr<Module> m(getLazyBitcodeModule(buffer, getGlobalContext(),
146                                            &errMsg));
147   if (!m) {
148     delete buffer;
149     return NULL;
150   }
151
152   std::string Triple = m->getTargetTriple();
153   if (Triple.empty())
154     Triple = sys::getDefaultTargetTriple();
155
156   // find machine architecture for this module
157   const Target *march = TargetRegistry::lookupTarget(Triple, errMsg);
158   if (!march)
159     return NULL;
160
161   // construct LTOModule, hand over ownership of module and target
162   SubtargetFeatures Features;
163   Features.getDefaultSubtargetFeatures(llvm::Triple(Triple));
164   std::string FeatureStr = Features.getString();
165   std::string CPU;
166   TargetMachine *target = march->createTargetMachine(Triple, CPU, FeatureStr);
167   LTOModule *Ret = new LTOModule(m.take(), target);
168   bool Err = Ret->ParseSymbols(errMsg);
169   if (Err) {
170     delete Ret;
171     return NULL;
172   }
173   return Ret;
174 }
175
176
177 const char *LTOModule::getTargetTriple() {
178   return _module->getTargetTriple().c_str();
179 }
180
181 void LTOModule::setTargetTriple(const char *triple) {
182   _module->setTargetTriple(triple);
183 }
184
185 void LTOModule::addDefinedFunctionSymbol(Function *f) {
186   // add to list of defined symbols
187   addDefinedSymbol(f, true);
188 }
189
190 // Get string that data pointer points to.
191 bool LTOModule::objcClassNameFromExpression(Constant *c, std::string &name) {
192   if (ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) {
193     Constant *op = ce->getOperand(0);
194     if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) {
195       Constant *cn = gvn->getInitializer();
196       if (ConstantArray *ca = dyn_cast<ConstantArray>(cn)) {
197         if (ca->isCString()) {
198           name = ".objc_class_name_" + ca->getAsCString();
199           return true;
200         }
201       }
202     }
203   }
204   return false;
205 }
206
207 // Parse i386/ppc ObjC class data structure.
208 void LTOModule::addObjCClass(GlobalVariable *clgv) {
209   if (ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer())) {
210     // second slot in __OBJC,__class is pointer to superclass name
211     std::string superclassName;
212     if (objcClassNameFromExpression(c->getOperand(1), superclassName)) {
213       NameAndAttributes info;
214       StringMap<NameAndAttributes>::value_type &entry =
215         _undefines.GetOrCreateValue(superclassName);
216       if (!entry.getValue().name) {
217         const char *symbolName = entry.getKey().data();
218         info.name = symbolName;
219         info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
220         entry.setValue(info);
221       }
222     }
223     // third slot in __OBJC,__class is pointer to class name
224     std::string className;
225     if (objcClassNameFromExpression(c->getOperand(2), className)) {
226       StringSet::value_type &entry =
227         _defines.GetOrCreateValue(className);
228       entry.setValue(1);
229       NameAndAttributes info;
230       info.name = entry.getKey().data();
231       info.attributes = (lto_symbol_attributes)
232         (LTO_SYMBOL_PERMISSIONS_DATA |
233          LTO_SYMBOL_DEFINITION_REGULAR |
234          LTO_SYMBOL_SCOPE_DEFAULT);
235       _symbols.push_back(info);
236     }
237   }
238 }
239
240
241 // Parse i386/ppc ObjC category data structure.
242 void LTOModule::addObjCCategory(GlobalVariable *clgv) {
243   if (ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer())) {
244     // second slot in __OBJC,__category is pointer to target class name
245     std::string targetclassName;
246     if (objcClassNameFromExpression(c->getOperand(1), targetclassName)) {
247       NameAndAttributes info;
248
249       StringMap<NameAndAttributes>::value_type &entry =
250         _undefines.GetOrCreateValue(targetclassName);
251
252       if (entry.getValue().name)
253         return;
254
255       const char *symbolName = entry.getKey().data();
256       info.name = symbolName;
257       info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
258       entry.setValue(info);
259     }
260   }
261 }
262
263
264 // Parse i386/ppc ObjC class list data structure.
265 void LTOModule::addObjCClassRef(GlobalVariable *clgv) {
266   std::string targetclassName;
267   if (objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) {
268     NameAndAttributes info;
269
270     StringMap<NameAndAttributes>::value_type &entry =
271       _undefines.GetOrCreateValue(targetclassName);
272     if (entry.getValue().name)
273       return;
274
275     const char *symbolName = entry.getKey().data();
276     info.name = symbolName;
277     info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
278     entry.setValue(info);
279   }
280 }
281
282
283 void LTOModule::addDefinedDataSymbol(GlobalValue *v) {
284   // Add to list of defined symbols.
285   addDefinedSymbol(v, false);
286
287   // Special case i386/ppc ObjC data structures in magic sections:
288   // The issue is that the old ObjC object format did some strange
289   // contortions to avoid real linker symbols.  For instance, the
290   // ObjC class data structure is allocated statically in the executable
291   // that defines that class.  That data structures contains a pointer to
292   // its superclass.  But instead of just initializing that part of the
293   // struct to the address of its superclass, and letting the static and
294   // dynamic linkers do the rest, the runtime works by having that field
295   // instead point to a C-string that is the name of the superclass.
296   // At runtime the objc initialization updates that pointer and sets
297   // it to point to the actual super class.  As far as the linker
298   // knows it is just a pointer to a string.  But then someone wanted the
299   // linker to issue errors at build time if the superclass was not found.
300   // So they figured out a way in mach-o object format to use an absolute
301   // symbols (.objc_class_name_Foo = 0) and a floating reference
302   // (.reference .objc_class_name_Bar) to cause the linker into erroring when
303   // a class was missing.
304   // The following synthesizes the implicit .objc_* symbols for the linker
305   // from the ObjC data structures generated by the front end.
306   if (v->hasSection() /* && isTargetDarwin */) {
307     // special case if this data blob is an ObjC class definition
308     if (v->getSection().compare(0, 15, "__OBJC,__class,") == 0) {
309       if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) {
310         addObjCClass(gv);
311       }
312     }
313
314     // special case if this data blob is an ObjC category definition
315     else if (v->getSection().compare(0, 18, "__OBJC,__category,") == 0) {
316       if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) {
317         addObjCCategory(gv);
318       }
319     }
320
321     // special case if this data blob is the list of referenced classes
322     else if (v->getSection().compare(0, 18, "__OBJC,__cls_refs,") == 0) {
323       if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) {
324         addObjCClassRef(gv);
325       }
326     }
327   }
328 }
329
330
331 void LTOModule::addDefinedSymbol(GlobalValue *def, bool isFunction) {
332   // ignore all llvm.* symbols
333   if (def->getName().startswith("llvm."))
334     return;
335
336   // string is owned by _defines
337   SmallString<64> Buffer;
338   _mangler.getNameWithPrefix(Buffer, def, false);
339
340   // set alignment part log2() can have rounding errors
341   uint32_t align = def->getAlignment();
342   uint32_t attr = align ? CountTrailingZeros_32(def->getAlignment()) : 0;
343
344   // set permissions part
345   if (isFunction)
346     attr |= LTO_SYMBOL_PERMISSIONS_CODE;
347   else {
348     GlobalVariable *gv = dyn_cast<GlobalVariable>(def);
349     if (gv && gv->isConstant())
350       attr |= LTO_SYMBOL_PERMISSIONS_RODATA;
351     else
352       attr |= LTO_SYMBOL_PERMISSIONS_DATA;
353   }
354
355   // set definition part
356   if (def->hasWeakLinkage() || def->hasLinkOnceLinkage() ||
357       def->hasLinkerPrivateWeakLinkage() ||
358       def->hasLinkerPrivateWeakDefAutoLinkage())
359     attr |= LTO_SYMBOL_DEFINITION_WEAK;
360   else if (def->hasCommonLinkage())
361     attr |= LTO_SYMBOL_DEFINITION_TENTATIVE;
362   else
363     attr |= LTO_SYMBOL_DEFINITION_REGULAR;
364
365   // set scope part
366   if (def->hasHiddenVisibility())
367     attr |= LTO_SYMBOL_SCOPE_HIDDEN;
368   else if (def->hasProtectedVisibility())
369     attr |= LTO_SYMBOL_SCOPE_PROTECTED;
370   else if (def->hasExternalLinkage() || def->hasWeakLinkage() ||
371            def->hasLinkOnceLinkage() || def->hasCommonLinkage() ||
372            def->hasLinkerPrivateWeakLinkage())
373     attr |= LTO_SYMBOL_SCOPE_DEFAULT;
374   else if (def->hasLinkerPrivateWeakDefAutoLinkage())
375     attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN;
376   else
377     attr |= LTO_SYMBOL_SCOPE_INTERNAL;
378
379   // add to table of symbols
380   NameAndAttributes info;
381   StringSet::value_type &entry = _defines.GetOrCreateValue(Buffer);
382   entry.setValue(1);
383
384   StringRef Name = entry.getKey();
385   info.name = Name.data();
386   assert(info.name[Name.size()] == '\0');
387   info.attributes = (lto_symbol_attributes)attr;
388   _symbols.push_back(info);
389 }
390
391 void LTOModule::addAsmGlobalSymbol(const char *name,
392                                    lto_symbol_attributes scope) {
393   StringSet::value_type &entry = _defines.GetOrCreateValue(name);
394
395   // only add new define if not already defined
396   if (entry.getValue())
397     return;
398
399   entry.setValue(1);
400   const char *symbolName = entry.getKey().data();
401   uint32_t attr = LTO_SYMBOL_DEFINITION_REGULAR;
402   attr |= scope;
403   NameAndAttributes info;
404   info.name = symbolName;
405   info.attributes = (lto_symbol_attributes)attr;
406   _symbols.push_back(info);
407 }
408
409 void LTOModule::addAsmGlobalSymbolUndef(const char *name) {
410   StringMap<NameAndAttributes>::value_type &entry =
411     _undefines.GetOrCreateValue(name);
412
413   _asm_undefines.push_back(entry.getKey().data());
414
415   // we already have the symbol
416   if (entry.getValue().name)
417     return;
418
419   uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED;;
420   attr |= LTO_SYMBOL_SCOPE_DEFAULT;
421   NameAndAttributes info;
422   info.name = entry.getKey().data();
423   info.attributes = (lto_symbol_attributes)attr;
424
425   entry.setValue(info);
426 }
427
428 void LTOModule::addPotentialUndefinedSymbol(GlobalValue *decl) {
429   // ignore all llvm.* symbols
430   if (decl->getName().startswith("llvm."))
431     return;
432
433   // ignore all aliases
434   if (isa<GlobalAlias>(decl))
435     return;
436
437   SmallString<64> name;
438   _mangler.getNameWithPrefix(name, decl, false);
439
440   StringMap<NameAndAttributes>::value_type &entry =
441     _undefines.GetOrCreateValue(name);
442
443   // we already have the symbol
444   if (entry.getValue().name)
445     return;
446
447   NameAndAttributes info;
448
449   info.name = entry.getKey().data();
450   if (decl->hasExternalWeakLinkage())
451     info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF;
452   else
453     info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
454
455   entry.setValue(info);
456 }
457
458
459 namespace {
460   class RecordStreamer : public MCStreamer {
461   public:
462     enum State { NeverSeen, Global, Defined, DefinedGlobal, Used};
463
464   private:
465     StringMap<State> Symbols;
466
467     void markDefined(const MCSymbol &Symbol) {
468       State &S = Symbols[Symbol.getName()];
469       switch (S) {
470       case DefinedGlobal:
471       case Global:
472         S = DefinedGlobal;
473         break;
474       case NeverSeen:
475       case Defined:
476       case Used:
477         S = Defined;
478         break;
479       }
480     }
481     void markGlobal(const MCSymbol &Symbol) {
482       State &S = Symbols[Symbol.getName()];
483       switch (S) {
484       case DefinedGlobal:
485       case Defined:
486         S = DefinedGlobal;
487         break;
488
489       case NeverSeen:
490       case Global:
491       case Used:
492         S = Global;
493         break;
494       }
495     }
496     void markUsed(const MCSymbol &Symbol) {
497       State &S = Symbols[Symbol.getName()];
498       switch (S) {
499       case DefinedGlobal:
500       case Defined:
501       case Global:
502         break;
503
504       case NeverSeen:
505       case Used:
506         S = Used;
507         break;
508       }
509     }
510
511     // FIXME: mostly copied for the obj streamer.
512     void AddValueSymbols(const MCExpr *Value) {
513       switch (Value->getKind()) {
514       case MCExpr::Target:
515         // FIXME: What should we do in here?
516         break;
517
518       case MCExpr::Constant:
519         break;
520
521       case MCExpr::Binary: {
522         const MCBinaryExpr *BE = cast<MCBinaryExpr>(Value);
523         AddValueSymbols(BE->getLHS());
524         AddValueSymbols(BE->getRHS());
525         break;
526       }
527
528       case MCExpr::SymbolRef:
529         markUsed(cast<MCSymbolRefExpr>(Value)->getSymbol());
530         break;
531
532       case MCExpr::Unary:
533         AddValueSymbols(cast<MCUnaryExpr>(Value)->getSubExpr());
534         break;
535       }
536     }
537
538   public:
539     typedef StringMap<State>::const_iterator const_iterator;
540
541     const_iterator begin() {
542       return Symbols.begin();
543     }
544
545     const_iterator end() {
546       return Symbols.end();
547     }
548
549     RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
550
551     virtual void ChangeSection(const MCSection *Section) {}
552     virtual void InitSections() {}
553     virtual void EmitLabel(MCSymbol *Symbol) {
554       Symbol->setSection(*getCurrentSection());
555       markDefined(*Symbol);
556     }
557     virtual void EmitAssemblerFlag(MCAssemblerFlag Flag) {}
558     virtual void EmitThumbFunc(MCSymbol *Func) {}
559     virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
560       // FIXME: should we handle aliases?
561       markDefined(*Symbol);
562     }
563     virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) {
564       if (Attribute == MCSA_Global)
565         markGlobal(*Symbol);
566     }
567     virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
568     virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
569     virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) {}
570     virtual void EmitCOFFSymbolStorageClass(int StorageClass) {}
571     virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
572                               unsigned Size , unsigned ByteAlignment) {
573       markDefined(*Symbol);
574     }
575     virtual void EmitCOFFSymbolType(int Type) {}
576     virtual void EndCOFFSymbolDef() {}
577     virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
578                                   unsigned ByteAlignment) {
579       markDefined(*Symbol);
580     }
581     virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
582     virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
583                                        unsigned ByteAlignment) {}
584     virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
585                                 uint64_t Size, unsigned ByteAlignment) {}
586     virtual void EmitBytes(StringRef Data, unsigned AddrSpace) {}
587     virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
588                                unsigned AddrSpace) {}
589     virtual void EmitULEB128Value(const MCExpr *Value) {}
590     virtual void EmitSLEB128Value(const MCExpr *Value) {}
591     virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
592                                       unsigned ValueSize,
593                                       unsigned MaxBytesToEmit) {}
594     virtual void EmitCodeAlignment(unsigned ByteAlignment,
595                                    unsigned MaxBytesToEmit) {}
596     virtual void EmitValueToOffset(const MCExpr *Offset,
597                                    unsigned char Value ) {}
598     virtual void EmitFileDirective(StringRef Filename) {}
599     virtual void EmitDwarfAdvanceLineAddr(int64_t LineDelta,
600                                           const MCSymbol *LastLabel,
601                                           const MCSymbol *Label,
602                                           unsigned PointerSize) {}
603
604     virtual void EmitInstruction(const MCInst &Inst) {
605       // Scan for values.
606       for (unsigned i = Inst.getNumOperands(); i--; )
607         if (Inst.getOperand(i).isExpr())
608           AddValueSymbols(Inst.getOperand(i).getExpr());
609     }
610     virtual void Finish() {}
611   };
612 }
613
614 bool LTOModule::addAsmGlobalSymbols(std::string &errMsg) {
615   const std::string &inlineAsm = _module->getModuleInlineAsm();
616   if (inlineAsm.empty())
617     return false;
618
619   OwningPtr<RecordStreamer> Streamer(new RecordStreamer(_context));
620   MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(inlineAsm);
621   SourceMgr SrcMgr;
622   SrcMgr.AddNewSourceBuffer(Buffer, SMLoc());
623   OwningPtr<MCAsmParser> Parser(createMCAsmParser(SrcMgr,
624                                                   _context, *Streamer,
625                                                   *_target->getMCAsmInfo()));
626   OwningPtr<MCSubtargetInfo> STI(_target->getTarget().
627                       createMCSubtargetInfo(_target->getTargetTriple(),
628                                             _target->getTargetCPU(),
629                                             _target->getTargetFeatureString()));
630   OwningPtr<MCTargetAsmParser>
631     TAP(_target->getTarget().createMCAsmParser(*STI, *Parser.get()));
632   if (!TAP) {
633     errMsg = "target " + std::string(_target->getTarget().getName()) +
634         " does not define AsmParser.";
635     return true;
636   }
637
638   Parser->setTargetParser(*TAP);
639   int Res = Parser->Run(false);
640   if (Res)
641     return true;
642
643   for (RecordStreamer::const_iterator i = Streamer->begin(),
644          e = Streamer->end(); i != e; ++i) {
645     StringRef Key = i->first();
646     RecordStreamer::State Value = i->second;
647     if (Value == RecordStreamer::DefinedGlobal)
648       addAsmGlobalSymbol(Key.data(), LTO_SYMBOL_SCOPE_DEFAULT);
649     else if (Value == RecordStreamer::Defined)
650       addAsmGlobalSymbol(Key.data(), LTO_SYMBOL_SCOPE_INTERNAL);
651     else if (Value == RecordStreamer::Global ||
652              Value == RecordStreamer::Used)
653       addAsmGlobalSymbolUndef(Key.data());
654   }
655   return false;
656 }
657
658 static bool isDeclaration(const GlobalValue &V) {
659   if (V.hasAvailableExternallyLinkage())
660     return true;
661   if (V.isMaterializable())
662     return false;
663   return V.isDeclaration();
664 }
665
666 static bool isAliasToDeclaration(const GlobalAlias &V) {
667   return isDeclaration(*V.getAliasedGlobal());
668 }
669
670 bool LTOModule::ParseSymbols(std::string &errMsg) {
671   // Use mangler to add GlobalPrefix to names to match linker names.
672
673   // add functions
674   for (Module::iterator f = _module->begin(); f != _module->end(); ++f) {
675     if (isDeclaration(*f))
676       addPotentialUndefinedSymbol(f);
677     else
678       addDefinedFunctionSymbol(f);
679   }
680
681   // add data
682   for (Module::global_iterator v = _module->global_begin(),
683          e = _module->global_end(); v !=  e; ++v) {
684     if (isDeclaration(*v))
685       addPotentialUndefinedSymbol(v);
686     else
687       addDefinedDataSymbol(v);
688   }
689
690   // add asm globals
691   if (addAsmGlobalSymbols(errMsg))
692     return true;
693
694   // add aliases
695   for (Module::alias_iterator i = _module->alias_begin(),
696          e = _module->alias_end(); i != e; ++i) {
697     if (isAliasToDeclaration(*i))
698       addPotentialUndefinedSymbol(i);
699     else
700       addDefinedDataSymbol(i);
701   }
702
703   // make symbols for all undefines
704   for (StringMap<NameAndAttributes>::iterator it=_undefines.begin();
705        it != _undefines.end(); ++it) {
706     // if this symbol also has a definition, then don't make an undefine
707     // because it is a tentative definition
708     if (_defines.count(it->getKey()) == 0) {
709       NameAndAttributes info = it->getValue();
710       _symbols.push_back(info);
711     }
712   }
713   return false;
714 }
715
716
717 uint32_t LTOModule::getSymbolCount() {
718   return _symbols.size();
719 }
720
721
722 lto_symbol_attributes LTOModule::getSymbolAttributes(uint32_t index) {
723   if (index < _symbols.size())
724     return _symbols[index].attributes;
725   else
726     return lto_symbol_attributes(0);
727 }
728
729 const char *LTOModule::getSymbolName(uint32_t index) {
730   if (index < _symbols.size())
731     return _symbols[index].name;
732   else
733     return NULL;
734 }