Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 1 | //===- lib/MC/MCELFStreamer.cpp - ELF Object Output ------------===// |
| 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 assembles .s files and emits ELF .o object files. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Jan Sjödin | 24b17c6 | 2011-03-03 14:52:12 +0000 | [diff] [blame^] | 14 | #include "MCELFStreamer.h" |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 15 | #include "MCELF.h" |
Jan Sjödin | 24b17c6 | 2011-03-03 14:52:12 +0000 | [diff] [blame^] | 16 | #include "llvm/MC/MCStreamer.h" |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 17 | #include "llvm/MC/MCCodeEmitter.h" |
| 18 | #include "llvm/MC/MCELFSymbolFlags.h" |
| 19 | #include "llvm/MC/MCExpr.h" |
| 20 | #include "llvm/MC/MCInst.h" |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 21 | #include "llvm/MC/MCSection.h" |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 22 | #include "llvm/MC/MCSymbol.h" |
Rafael Espindola | 484291c | 2010-11-01 14:28:48 +0000 | [diff] [blame] | 23 | #include "llvm/MC/MCValue.h" |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 24 | #include "llvm/Support/Debug.h" |
| 25 | #include "llvm/Support/ELF.h" |
| 26 | #include "llvm/Support/ErrorHandling.h" |
| 27 | #include "llvm/Support/raw_ostream.h" |
| 28 | #include "llvm/Target/TargetAsmBackend.h" |
Rafael Espindola | 89b9372 | 2010-12-10 07:39:47 +0000 | [diff] [blame] | 29 | #include "llvm/Target/TargetAsmInfo.h" |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 30 | |
| 31 | using namespace llvm; |
| 32 | |
Rafael Espindola | d80781b | 2010-09-15 21:48:40 +0000 | [diff] [blame] | 33 | void MCELFStreamer::InitSections() { |
| 34 | // This emulates the same behavior of GNU as. This makes it easier |
| 35 | // to compare the output as the major sections are in the same order. |
| 36 | SetSectionText(); |
| 37 | SetSectionData(); |
| 38 | SetSectionBss(); |
| 39 | SetSectionText(); |
| 40 | } |
| 41 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 42 | void MCELFStreamer::EmitLabel(MCSymbol *Symbol) { |
Rafael Espindola | ba21024 | 2010-11-28 16:22:59 +0000 | [diff] [blame] | 43 | assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); |
| 44 | |
Rafael Espindola | ea4afa9 | 2010-11-28 17:18:55 +0000 | [diff] [blame] | 45 | MCObjectStreamer::EmitLabel(Symbol); |
Rafael Espindola | 73ffea4 | 2010-09-25 05:42:19 +0000 | [diff] [blame] | 46 | |
Rafael Espindola | e1a2587 | 2010-11-11 19:04:55 +0000 | [diff] [blame] | 47 | const MCSectionELF &Section = |
| 48 | static_cast<const MCSectionELF&>(Symbol->getSection()); |
Rafael Espindola | ea4afa9 | 2010-11-28 17:18:55 +0000 | [diff] [blame] | 49 | MCSymbolData &SD = getAssembler().getSymbolData(*Symbol); |
Rafael Espindola | 1c13026 | 2011-01-23 04:43:11 +0000 | [diff] [blame] | 50 | if (Section.getFlags() & ELF::SHF_TLS) |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 51 | MCELF::SetType(SD, ELF::STT_TLS); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { |
| 55 | switch (Flag) { |
Jim Grosbach | ce79299 | 2010-11-05 22:08:08 +0000 | [diff] [blame] | 56 | case MCAF_SyntaxUnified: return; // no-op here. |
| 57 | case MCAF_Code16: return; // no-op here. |
Jim Grosbach | ba21957 | 2010-11-05 22:40:09 +0000 | [diff] [blame] | 58 | case MCAF_Code32: return; // no-op here. |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 59 | case MCAF_SubsectionsViaSymbols: |
| 60 | getAssembler().setSubsectionsViaSymbols(true); |
| 61 | return; |
| 62 | } |
| 63 | |
| 64 | assert(0 && "invalid assembler flag!"); |
| 65 | } |
| 66 | |
Jim Grosbach | ce79299 | 2010-11-05 22:08:08 +0000 | [diff] [blame] | 67 | void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) { |
| 68 | // FIXME: Anything needed here to flag the function as thumb? |
| 69 | } |
| 70 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 71 | void MCELFStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { |
| 72 | // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into |
| 73 | // MCObjectStreamer. |
| 74 | // FIXME: Lift context changes into super class. |
| 75 | getAssembler().getOrCreateSymbolData(*Symbol); |
| 76 | Symbol->setVariableValue(AddValueSymbols(Value)); |
| 77 | } |
| 78 | |
Rafael Espindola | 7768a9d | 2011-02-16 01:08:29 +0000 | [diff] [blame] | 79 | void MCELFStreamer::ChangeSection(const MCSection *Section) { |
Rafael Espindola | 1f4f9e3 | 2010-11-14 04:17:37 +0000 | [diff] [blame] | 80 | const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup(); |
| 81 | if (Grp) |
| 82 | getAssembler().getOrCreateSymbolData(*Grp); |
Rafael Espindola | 7768a9d | 2011-02-16 01:08:29 +0000 | [diff] [blame] | 83 | this->MCObjectStreamer::ChangeSection(Section); |
Rafael Espindola | 1f4f9e3 | 2010-11-14 04:17:37 +0000 | [diff] [blame] | 84 | } |
| 85 | |
Rafael Espindola | 484291c | 2010-11-01 14:28:48 +0000 | [diff] [blame] | 86 | void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) { |
| 87 | getAssembler().getOrCreateSymbolData(*Symbol); |
| 88 | MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias); |
| 89 | AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref); |
Rafael Espindola | 94ed5fc | 2010-11-15 16:33:49 +0000 | [diff] [blame] | 90 | const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext()); |
Rafael Espindola | 484291c | 2010-11-01 14:28:48 +0000 | [diff] [blame] | 91 | Alias->setVariableValue(Value); |
| 92 | } |
| 93 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 94 | void MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol, |
| 95 | MCSymbolAttr Attribute) { |
| 96 | // Indirect symbols are handled differently, to match how 'as' handles |
| 97 | // them. This makes writing matching .o files easier. |
| 98 | if (Attribute == MCSA_IndirectSymbol) { |
| 99 | // Note that we intentionally cannot use the symbol data here; this is |
| 100 | // important for matching the string table that 'as' generates. |
| 101 | IndirectSymbolData ISD; |
| 102 | ISD.Symbol = Symbol; |
| 103 | ISD.SectionData = getCurrentSectionData(); |
| 104 | getAssembler().getIndirectSymbols().push_back(ISD); |
| 105 | return; |
| 106 | } |
| 107 | |
| 108 | // Adding a symbol attribute always introduces the symbol, note that an |
| 109 | // important side effect of calling getOrCreateSymbolData here is to register |
| 110 | // the symbol with the assembler. |
| 111 | MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); |
| 112 | |
| 113 | // The implementation of symbol attributes is designed to match 'as', but it |
| 114 | // leaves much to desired. It doesn't really make sense to arbitrarily add and |
| 115 | // remove flags, but 'as' allows this (in particular, see .desc). |
| 116 | // |
| 117 | // In the future it might be worth trying to make these operations more well |
| 118 | // defined. |
| 119 | switch (Attribute) { |
| 120 | case MCSA_LazyReference: |
| 121 | case MCSA_Reference: |
| 122 | case MCSA_NoDeadStrip: |
Kevin Enderby | e8e98d7 | 2010-11-19 18:39:33 +0000 | [diff] [blame] | 123 | case MCSA_SymbolResolver: |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 124 | case MCSA_PrivateExtern: |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 125 | case MCSA_WeakDefinition: |
Eli Friedman | f8020a3 | 2010-08-16 19:15:06 +0000 | [diff] [blame] | 126 | case MCSA_WeakDefAutoPrivate: |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 127 | case MCSA_Invalid: |
| 128 | case MCSA_ELF_TypeIndFunction: |
| 129 | case MCSA_IndirectSymbol: |
| 130 | assert(0 && "Invalid symbol attribute for ELF!"); |
| 131 | break; |
| 132 | |
Rafael Espindola | 7e528a1 | 2010-11-14 01:34:31 +0000 | [diff] [blame] | 133 | case MCSA_ELF_TypeGnuUniqueObject: |
| 134 | // Ignore for now. |
| 135 | break; |
| 136 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 137 | case MCSA_Global: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 138 | MCELF::SetBinding(SD, ELF::STB_GLOBAL); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 139 | SD.setExternal(true); |
Rafael Espindola | f7c10a3 | 2010-09-21 00:24:38 +0000 | [diff] [blame] | 140 | BindingExplicitlySet.insert(Symbol); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 141 | break; |
| 142 | |
Benjamin Kramer | 230c274 | 2010-09-02 17:18:32 +0000 | [diff] [blame] | 143 | case MCSA_WeakReference: |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 144 | case MCSA_Weak: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 145 | MCELF::SetBinding(SD, ELF::STB_WEAK); |
Rafael Espindola | 3223f19 | 2010-10-06 16:47:31 +0000 | [diff] [blame] | 146 | SD.setExternal(true); |
Rafael Espindola | f7c10a3 | 2010-09-21 00:24:38 +0000 | [diff] [blame] | 147 | BindingExplicitlySet.insert(Symbol); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 148 | break; |
| 149 | |
| 150 | case MCSA_Local: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 151 | MCELF::SetBinding(SD, ELF::STB_LOCAL); |
Rafael Espindola | f7c10a3 | 2010-09-21 00:24:38 +0000 | [diff] [blame] | 152 | SD.setExternal(false); |
| 153 | BindingExplicitlySet.insert(Symbol); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 154 | break; |
| 155 | |
| 156 | case MCSA_ELF_TypeFunction: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 157 | MCELF::SetType(SD, ELF::STT_FUNC); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 158 | break; |
| 159 | |
| 160 | case MCSA_ELF_TypeObject: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 161 | MCELF::SetType(SD, ELF::STT_OBJECT); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 162 | break; |
| 163 | |
| 164 | case MCSA_ELF_TypeTLS: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 165 | MCELF::SetType(SD, ELF::STT_TLS); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 166 | break; |
| 167 | |
| 168 | case MCSA_ELF_TypeCommon: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 169 | MCELF::SetType(SD, ELF::STT_COMMON); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 170 | break; |
| 171 | |
| 172 | case MCSA_ELF_TypeNoType: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 173 | MCELF::SetType(SD, ELF::STT_NOTYPE); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 174 | break; |
| 175 | |
| 176 | case MCSA_Protected: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 177 | MCELF::SetVisibility(SD, ELF::STV_PROTECTED); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 178 | break; |
| 179 | |
| 180 | case MCSA_Hidden: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 181 | MCELF::SetVisibility(SD, ELF::STV_HIDDEN); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 182 | break; |
| 183 | |
| 184 | case MCSA_Internal: |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 185 | MCELF::SetVisibility(SD, ELF::STV_INTERNAL); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 186 | break; |
| 187 | } |
| 188 | } |
| 189 | |
| 190 | void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, |
| 191 | unsigned ByteAlignment) { |
| 192 | MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); |
| 193 | |
Rafael Espindola | f7c10a3 | 2010-09-21 00:24:38 +0000 | [diff] [blame] | 194 | if (!BindingExplicitlySet.count(Symbol)) { |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 195 | MCELF::SetBinding(SD, ELF::STB_GLOBAL); |
Rafael Espindola | f7c10a3 | 2010-09-21 00:24:38 +0000 | [diff] [blame] | 196 | SD.setExternal(true); |
| 197 | } |
| 198 | |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 199 | MCELF::SetType(SD, ELF::STT_OBJECT); |
Rafael Espindola | 55d02f3 | 2010-11-14 21:11:16 +0000 | [diff] [blame] | 200 | |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 201 | if (MCELF::GetBinding(SD) == ELF_STB_Local) { |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 202 | const MCSection *Section = getAssembler().getContext().getELFSection(".bss", |
Rafael Espindola | c85dca6 | 2011-01-23 04:28:49 +0000 | [diff] [blame] | 203 | ELF::SHT_NOBITS, |
Rafael Espindola | 1c13026 | 2011-01-23 04:43:11 +0000 | [diff] [blame] | 204 | ELF::SHF_WRITE | |
| 205 | ELF::SHF_ALLOC, |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 206 | SectionKind::getBSS()); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 207 | Symbol->setSection(*Section); |
Rafael Espindola | 1963572 | 2010-09-22 17:43:04 +0000 | [diff] [blame] | 208 | |
Rafael Espindola | 9e3922e | 2010-09-29 14:52:01 +0000 | [diff] [blame] | 209 | struct LocalCommon L = {&SD, Size, ByteAlignment}; |
| 210 | LocalCommons.push_back(L); |
Rafael Espindola | f7c10a3 | 2010-09-21 00:24:38 +0000 | [diff] [blame] | 211 | } else { |
| 212 | SD.setCommon(Size, ByteAlignment); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Rafael Espindola | f7c10a3 | 2010-09-21 00:24:38 +0000 | [diff] [blame] | 215 | SD.setSize(MCConstantExpr::Create(Size, getContext())); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 216 | } |
| 217 | |
Jason W Kim | f13743b | 2010-12-16 03:12:17 +0000 | [diff] [blame] | 218 | void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) { |
| 219 | // FIXME: Should this be caught and done earlier? |
| 220 | MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 221 | MCELF::SetBinding(SD, ELF::STB_LOCAL); |
Jason W Kim | f13743b | 2010-12-16 03:12:17 +0000 | [diff] [blame] | 222 | SD.setExternal(false); |
| 223 | BindingExplicitlySet.insert(Symbol); |
| 224 | // FIXME: ByteAlignment is not needed here, but is required. |
| 225 | EmitCommonSymbol(Symbol, Size, 1); |
| 226 | } |
| 227 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 228 | void MCELFStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) { |
| 229 | // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into |
| 230 | // MCObjectStreamer. |
| 231 | getOrCreateDataFragment()->getContents().append(Data.begin(), Data.end()); |
| 232 | } |
| 233 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 234 | void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment, |
| 235 | int64_t Value, unsigned ValueSize, |
| 236 | unsigned MaxBytesToEmit) { |
| 237 | // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into |
| 238 | // MCObjectStreamer. |
| 239 | if (MaxBytesToEmit == 0) |
| 240 | MaxBytesToEmit = ByteAlignment; |
| 241 | new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit, |
| 242 | getCurrentSectionData()); |
| 243 | |
| 244 | // Update the maximum alignment on the current section if necessary. |
| 245 | if (ByteAlignment > getCurrentSectionData()->getAlignment()) |
| 246 | getCurrentSectionData()->setAlignment(ByteAlignment); |
| 247 | } |
| 248 | |
| 249 | void MCELFStreamer::EmitCodeAlignment(unsigned ByteAlignment, |
| 250 | unsigned MaxBytesToEmit) { |
| 251 | // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into |
| 252 | // MCObjectStreamer. |
| 253 | if (MaxBytesToEmit == 0) |
| 254 | MaxBytesToEmit = ByteAlignment; |
| 255 | MCAlignFragment *F = new MCAlignFragment(ByteAlignment, 0, 1, MaxBytesToEmit, |
| 256 | getCurrentSectionData()); |
| 257 | F->setEmitNops(true); |
| 258 | |
| 259 | // Update the maximum alignment on the current section if necessary. |
| 260 | if (ByteAlignment > getCurrentSectionData()->getAlignment()) |
| 261 | getCurrentSectionData()->setAlignment(ByteAlignment); |
| 262 | } |
| 263 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 264 | // Add a symbol for the file name of this module. This is the second |
| 265 | // entry in the module's symbol table (the first being the null symbol). |
| 266 | void MCELFStreamer::EmitFileDirective(StringRef Filename) { |
| 267 | MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename); |
Rafael Espindola | 7768a9d | 2011-02-16 01:08:29 +0000 | [diff] [blame] | 268 | Symbol->setSection(*getCurrentSection()); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 269 | Symbol->setAbsolute(); |
| 270 | |
| 271 | MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); |
| 272 | |
| 273 | SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default); |
| 274 | } |
| 275 | |
Rafael Espindola | 9755127 | 2010-11-24 02:19:40 +0000 | [diff] [blame] | 276 | void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) { |
| 277 | switch (expr->getKind()) { |
| 278 | case MCExpr::Target: llvm_unreachable("Can't handle target exprs yet!"); |
| 279 | case MCExpr::Constant: |
| 280 | break; |
| 281 | |
| 282 | case MCExpr::Binary: { |
| 283 | const MCBinaryExpr *be = cast<MCBinaryExpr>(expr); |
| 284 | fixSymbolsInTLSFixups(be->getLHS()); |
| 285 | fixSymbolsInTLSFixups(be->getRHS()); |
| 286 | break; |
| 287 | } |
| 288 | |
| 289 | case MCExpr::SymbolRef: { |
| 290 | const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr); |
Rafael Espindola | bf8209d | 2010-11-24 18:51:21 +0000 | [diff] [blame] | 291 | switch (symRef.getKind()) { |
| 292 | default: |
Rafael Espindola | 9755127 | 2010-11-24 02:19:40 +0000 | [diff] [blame] | 293 | return; |
Rafael Espindola | bf8209d | 2010-11-24 18:51:21 +0000 | [diff] [blame] | 294 | case MCSymbolRefExpr::VK_NTPOFF: |
| 295 | case MCSymbolRefExpr::VK_GOTNTPOFF: |
| 296 | case MCSymbolRefExpr::VK_TLSGD: |
| 297 | case MCSymbolRefExpr::VK_TLSLDM: |
| 298 | case MCSymbolRefExpr::VK_TPOFF: |
| 299 | case MCSymbolRefExpr::VK_DTPOFF: |
| 300 | case MCSymbolRefExpr::VK_GOTTPOFF: |
| 301 | case MCSymbolRefExpr::VK_TLSLD: |
| 302 | case MCSymbolRefExpr::VK_ARM_TLSGD: |
| 303 | break; |
| 304 | } |
Rafael Espindola | 9755127 | 2010-11-24 02:19:40 +0000 | [diff] [blame] | 305 | MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol()); |
Jan Sjödin | 2ddfd95 | 2011-02-28 21:45:04 +0000 | [diff] [blame] | 306 | MCELF::SetType(SD, ELF::STT_TLS); |
Rafael Espindola | 9755127 | 2010-11-24 02:19:40 +0000 | [diff] [blame] | 307 | break; |
| 308 | } |
| 309 | |
| 310 | case MCExpr::Unary: |
| 311 | fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr()); |
| 312 | break; |
| 313 | } |
| 314 | } |
| 315 | |
Benjamin Kramer | 93ded73 | 2010-08-27 10:40:51 +0000 | [diff] [blame] | 316 | void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) { |
Rafael Espindola | dedb045 | 2010-12-02 05:44:06 +0000 | [diff] [blame] | 317 | this->MCObjectStreamer::EmitInstToFragment(Inst); |
| 318 | MCInstFragment &F = *cast<MCInstFragment>(getCurrentFragment()); |
Benjamin Kramer | 93ded73 | 2010-08-27 10:40:51 +0000 | [diff] [blame] | 319 | |
Rafael Espindola | dedb045 | 2010-12-02 05:44:06 +0000 | [diff] [blame] | 320 | for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i) |
| 321 | fixSymbolsInTLSFixups(F.getFixups()[i].getValue()); |
Benjamin Kramer | 93ded73 | 2010-08-27 10:40:51 +0000 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | void MCELFStreamer::EmitInstToData(const MCInst &Inst) { |
| 325 | MCDataFragment *DF = getOrCreateDataFragment(); |
| 326 | |
| 327 | SmallVector<MCFixup, 4> Fixups; |
| 328 | SmallString<256> Code; |
| 329 | raw_svector_ostream VecOS(Code); |
| 330 | getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups); |
| 331 | VecOS.flush(); |
| 332 | |
Rafael Espindola | 9755127 | 2010-11-24 02:19:40 +0000 | [diff] [blame] | 333 | for (unsigned i = 0, e = Fixups.size(); i != e; ++i) |
| 334 | fixSymbolsInTLSFixups(Fixups[i].getValue()); |
| 335 | |
Benjamin Kramer | 93ded73 | 2010-08-27 10:40:51 +0000 | [diff] [blame] | 336 | // Add the fixups and data. |
| 337 | for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { |
| 338 | Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size()); |
| 339 | DF->addFixup(Fixups[i]); |
| 340 | } |
| 341 | DF->getContents().append(Code.begin(), Code.end()); |
| 342 | } |
| 343 | |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 344 | void MCELFStreamer::Finish() { |
Rafael Espindola | d7c8cca | 2010-12-26 20:20:31 +0000 | [diff] [blame] | 345 | if (getNumFrameInfos()) |
Rafael Espindola | 89b9372 | 2010-12-10 07:39:47 +0000 | [diff] [blame] | 346 | MCDwarfFrameEmitter::Emit(*this); |
Rafael Espindola | c70a1d9 | 2010-11-01 17:07:14 +0000 | [diff] [blame] | 347 | |
Rafael Espindola | 9e3922e | 2010-09-29 14:52:01 +0000 | [diff] [blame] | 348 | for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(), |
| 349 | e = LocalCommons.end(); |
| 350 | i != e; ++i) { |
| 351 | MCSymbolData *SD = i->SD; |
| 352 | uint64_t Size = i->Size; |
| 353 | unsigned ByteAlignment = i->ByteAlignment; |
| 354 | const MCSymbol &Symbol = SD->getSymbol(); |
| 355 | const MCSection &Section = Symbol.getSection(); |
| 356 | |
| 357 | MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section); |
| 358 | new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData); |
| 359 | |
| 360 | MCFragment *F = new MCFillFragment(0, 0, Size, &SectData); |
| 361 | SD->setFragment(F); |
| 362 | |
| 363 | // Update the maximum alignment of the section if necessary. |
| 364 | if (ByteAlignment > SectData.getAlignment()) |
| 365 | SectData.setAlignment(ByteAlignment); |
| 366 | } |
| 367 | |
Rafael Espindola | 73ffea4 | 2010-09-25 05:42:19 +0000 | [diff] [blame] | 368 | this->MCObjectStreamer::Finish(); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 369 | } |
| 370 | |
| 371 | MCStreamer *llvm::createELFStreamer(MCContext &Context, TargetAsmBackend &TAB, |
Rafael Espindola | 96aa78c | 2011-01-23 17:55:27 +0000 | [diff] [blame] | 372 | raw_ostream &OS, MCCodeEmitter *CE, |
| 373 | bool RelaxAll, bool NoExecStack) { |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 374 | MCELFStreamer *S = new MCELFStreamer(Context, TAB, OS, CE); |
| 375 | if (RelaxAll) |
| 376 | S->getAssembler().setRelaxAll(true); |
Rafael Espindola | 96aa78c | 2011-01-23 17:55:27 +0000 | [diff] [blame] | 377 | if (NoExecStack) |
| 378 | S->getAssembler().setNoExecStack(true); |
Matt Fleming | 3565a06 | 2010-08-16 18:57:57 +0000 | [diff] [blame] | 379 | return S; |
| 380 | } |