blob: 251e1f561581fe86d2c04bf1b84a3d5f337f1676 [file] [log] [blame]
Tim Northover5cc3dc82012-12-07 16:50:23 +00001//===- lib/MC/ARMELFStreamer.cpp - ELF Object Output for ARM --------------===//
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 ARM ELF .o object files. Different
11// from generic ELF streamer in emitting mapping symbols ($a, $t and $d) to
12// delimit regions of data and code.
13//
14//===----------------------------------------------------------------------===//
15
Logan Chiend8bb4b72013-04-16 12:02:21 +000016#include "ARMRegisterInfo.h"
Logan Chiend8bb4b72013-04-16 12:02:21 +000017#include "ARMUnwindOpAsm.h"
Saleem Abdulrasoolc0da2cb2013-12-19 05:17:58 +000018#include "llvm/ADT/StringExtras.h"
Benjamin Kramerf242d8c2012-12-08 10:45:24 +000019#include "llvm/ADT/Twine.h"
20#include "llvm/MC/MCAsmBackend.h"
Saleem Abdulrasoolc0da2cb2013-12-19 05:17:58 +000021#include "llvm/MC/MCAsmInfo.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000022#include "llvm/MC/MCAssembler.h"
23#include "llvm/MC/MCCodeEmitter.h"
24#include "llvm/MC/MCContext.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000025#include "llvm/MC/MCELFStreamer.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000026#include "llvm/MC/MCExpr.h"
27#include "llvm/MC/MCInst.h"
Rafael Espindolaa17151a2013-10-08 13:08:17 +000028#include "llvm/MC/MCInstPrinter.h"
Rafael Espindola4c6f6132014-04-27 17:10:46 +000029#include "llvm/MC/MCObjectFileInfo.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000030#include "llvm/MC/MCObjectStreamer.h"
Logan Chiend8bb4b72013-04-16 12:02:21 +000031#include "llvm/MC/MCRegisterInfo.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000032#include "llvm/MC/MCSection.h"
Benjamin Kramerf242d8c2012-12-08 10:45:24 +000033#include "llvm/MC/MCSectionELF.h"
34#include "llvm/MC/MCStreamer.h"
Rafael Espindola95fb9b92015-06-02 20:38:46 +000035#include "llvm/MC/MCSymbolELF.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000036#include "llvm/MC/MCValue.h"
Saleem Abdulrasool278a9f42014-01-19 08:25:27 +000037#include "llvm/Support/ARMBuildAttributes.h"
Saleem Abdulrasoolb961c992014-01-06 00:15:00 +000038#include "llvm/Support/ARMEHABI.h"
Renato Golinf5f373f2015-05-08 21:04:27 +000039#include "llvm/Support/TargetParser.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000040#include "llvm/Support/Debug.h"
41#include "llvm/Support/ELF.h"
Rafael Espindolaa17151a2013-10-08 13:08:17 +000042#include "llvm/Support/FormattedStream.h"
Logan Chien5b776b72014-02-22 14:00:39 +000043#include "llvm/Support/LEB128.h"
Tim Northover5cc3dc82012-12-07 16:50:23 +000044#include "llvm/Support/raw_ostream.h"
Logan Chien8cbb80d2013-10-28 17:51:12 +000045#include <algorithm>
Tim Northover5cc3dc82012-12-07 16:50:23 +000046
47using namespace llvm;
48
Logan Chiend8bb4b72013-04-16 12:02:21 +000049static std::string GetAEABIUnwindPersonalityName(unsigned Index) {
Saleem Abdulrasoolb961c992014-01-06 00:15:00 +000050 assert(Index < ARM::EHABI::NUM_PERSONALITY_INDEX &&
51 "Invalid personality index");
Logan Chiend8bb4b72013-04-16 12:02:21 +000052 return (Twine("__aeabi_unwind_cpp_pr") + Twine(Index)).str();
53}
54
Tim Northover5cc3dc82012-12-07 16:50:23 +000055namespace {
56
Rafael Espindolaa17151a2013-10-08 13:08:17 +000057class ARMELFStreamer;
58
59class ARMTargetAsmStreamer : public ARMTargetStreamer {
60 formatted_raw_ostream &OS;
61 MCInstPrinter &InstPrinter;
Saleem Abdulrasoolf16e68a2014-01-07 02:28:50 +000062 bool IsVerboseAsm;
Rafael Espindolaa17151a2013-10-08 13:08:17 +000063
Craig Topperca7e3e52014-03-10 03:19:03 +000064 void emitFnStart() override;
65 void emitFnEnd() override;
66 void emitCantUnwind() override;
67 void emitPersonality(const MCSymbol *Personality) override;
68 void emitPersonalityIndex(unsigned Index) override;
69 void emitHandlerData() override;
70 void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
71 void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
72 void emitPad(int64_t Offset) override;
73 void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
74 bool isVector) override;
75 void emitUnwindRaw(int64_t Offset,
76 const SmallVectorImpl<uint8_t> &Opcodes) override;
Rafael Espindolaa17151a2013-10-08 13:08:17 +000077
Craig Topperca7e3e52014-03-10 03:19:03 +000078 void switchVendor(StringRef Vendor) override;
79 void emitAttribute(unsigned Attribute, unsigned Value) override;
80 void emitTextAttribute(unsigned Attribute, StringRef String) override;
81 void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
82 StringRef StrinValue) override;
83 void emitArch(unsigned Arch) override;
Sumanth Gundapanenia9049ea2015-02-26 18:07:35 +000084 void emitArchExtension(unsigned ArchExt) override;
Craig Topperca7e3e52014-03-10 03:19:03 +000085 void emitObjectArch(unsigned Arch) override;
86 void emitFPU(unsigned FPU) override;
87 void emitInst(uint32_t Inst, char Suffix = '\0') override;
88 void finishAttributeSection() override;
Logan Chien8cbb80d2013-10-28 17:51:12 +000089
Craig Topperca7e3e52014-03-10 03:19:03 +000090 void AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
Rafael Espindola466d6632014-04-27 20:23:58 +000091 void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
Saleem Abdulrasool56e06e82014-01-30 04:02:47 +000092
Rafael Espindolaa17151a2013-10-08 13:08:17 +000093public:
Rafael Espindola24ea09e2014-01-26 06:06:37 +000094 ARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS,
95 MCInstPrinter &InstPrinter, bool VerboseAsm);
Rafael Espindolaa17151a2013-10-08 13:08:17 +000096};
97
Rafael Espindola24ea09e2014-01-26 06:06:37 +000098ARMTargetAsmStreamer::ARMTargetAsmStreamer(MCStreamer &S,
99 formatted_raw_ostream &OS,
Saleem Abdulrasoolf16e68a2014-01-07 02:28:50 +0000100 MCInstPrinter &InstPrinter,
101 bool VerboseAsm)
Rafael Espindola24ea09e2014-01-26 06:06:37 +0000102 : ARMTargetStreamer(S), OS(OS), InstPrinter(InstPrinter),
103 IsVerboseAsm(VerboseAsm) {}
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000104void ARMTargetAsmStreamer::emitFnStart() { OS << "\t.fnstart\n"; }
105void ARMTargetAsmStreamer::emitFnEnd() { OS << "\t.fnend\n"; }
106void ARMTargetAsmStreamer::emitCantUnwind() { OS << "\t.cantunwind\n"; }
107void ARMTargetAsmStreamer::emitPersonality(const MCSymbol *Personality) {
108 OS << "\t.personality " << Personality->getName() << '\n';
109}
Saleem Abdulrasool662f5c12014-01-21 02:33:02 +0000110void ARMTargetAsmStreamer::emitPersonalityIndex(unsigned Index) {
111 OS << "\t.personalityindex " << Index << '\n';
112}
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000113void ARMTargetAsmStreamer::emitHandlerData() { OS << "\t.handlerdata\n"; }
114void ARMTargetAsmStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
115 int64_t Offset) {
116 OS << "\t.setfp\t";
117 InstPrinter.printRegName(OS, FpReg);
118 OS << ", ";
119 InstPrinter.printRegName(OS, SpReg);
120 if (Offset)
121 OS << ", #" << Offset;
122 OS << '\n';
123}
Saleem Abdulrasool5d962d32014-01-30 04:46:24 +0000124void ARMTargetAsmStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
125 assert((Reg != ARM::SP && Reg != ARM::PC) &&
126 "the operand of .movsp cannot be either sp or pc");
127
128 OS << "\t.movsp\t";
129 InstPrinter.printRegName(OS, Reg);
130 if (Offset)
131 OS << ", #" << Offset;
132 OS << '\n';
133}
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000134void ARMTargetAsmStreamer::emitPad(int64_t Offset) {
135 OS << "\t.pad\t#" << Offset << '\n';
136}
137void ARMTargetAsmStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
138 bool isVector) {
139 assert(RegList.size() && "RegList should not be empty");
140 if (isVector)
141 OS << "\t.vsave\t{";
142 else
143 OS << "\t.save\t{";
144
145 InstPrinter.printRegName(OS, RegList[0]);
146
147 for (unsigned i = 1, e = RegList.size(); i != e; ++i) {
148 OS << ", ";
149 InstPrinter.printRegName(OS, RegList[i]);
150 }
151
152 OS << "}\n";
153}
Logan Chien8cbb80d2013-10-28 17:51:12 +0000154void ARMTargetAsmStreamer::switchVendor(StringRef Vendor) {
155}
156void ARMTargetAsmStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
Saleem Abdulrasoolf16e68a2014-01-07 02:28:50 +0000157 OS << "\t.eabi_attribute\t" << Attribute << ", " << Twine(Value);
158 if (IsVerboseAsm) {
159 StringRef Name = ARMBuildAttrs::AttrTypeAsString(Attribute);
160 if (!Name.empty())
161 OS << "\t@ " << Name;
162 }
163 OS << "\n";
Logan Chien8cbb80d2013-10-28 17:51:12 +0000164}
165void ARMTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
166 StringRef String) {
167 switch (Attribute) {
Logan Chien8cbb80d2013-10-28 17:51:12 +0000168 case ARMBuildAttrs::CPU_name:
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000169 OS << "\t.cpu\t" << String.lower();
170 break;
171 default:
172 OS << "\t.eabi_attribute\t" << Attribute << ", \"" << String << "\"";
Saleem Abdulrasoolf16e68a2014-01-07 02:28:50 +0000173 if (IsVerboseAsm) {
174 StringRef Name = ARMBuildAttrs::AttrTypeAsString(Attribute);
175 if (!Name.empty())
176 OS << "\t@ " << Name;
177 }
Logan Chien8cbb80d2013-10-28 17:51:12 +0000178 break;
179 }
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000180 OS << "\n";
181}
182void ARMTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
183 unsigned IntValue,
184 StringRef StringValue) {
185 switch (Attribute) {
186 default: llvm_unreachable("unsupported multi-value attribute in asm mode");
187 case ARMBuildAttrs::compatibility:
188 OS << "\t.eabi_attribute\t" << Attribute << ", " << IntValue;
189 if (!StringValue.empty())
190 OS << ", \"" << StringValue << "\"";
Saleem Abdulrasoolf16e68a2014-01-07 02:28:50 +0000191 if (IsVerboseAsm)
192 OS << "\t@ " << ARMBuildAttrs::AttrTypeAsString(Attribute);
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000193 break;
194 }
195 OS << "\n";
Logan Chien8cbb80d2013-10-28 17:51:12 +0000196}
Logan Chien439e8f92013-12-11 17:16:25 +0000197void ARMTargetAsmStreamer::emitArch(unsigned Arch) {
Renato Golinf5f373f2015-05-08 21:04:27 +0000198 OS << "\t.arch\t" << ARMTargetParser::getArchName(Arch) << "\n";
Logan Chien439e8f92013-12-11 17:16:25 +0000199}
Sumanth Gundapanenia9049ea2015-02-26 18:07:35 +0000200void ARMTargetAsmStreamer::emitArchExtension(unsigned ArchExt) {
Renato Golinf5f373f2015-05-08 21:04:27 +0000201 OS << "\t.arch_extension\t" << ARMTargetParser::getArchExtName(ArchExt) << "\n";
Sumanth Gundapanenia9049ea2015-02-26 18:07:35 +0000202}
Saleem Abdulrasool4c4789b2014-01-30 04:46:41 +0000203void ARMTargetAsmStreamer::emitObjectArch(unsigned Arch) {
Renato Golinf5f373f2015-05-08 21:04:27 +0000204 OS << "\t.object_arch\t" << ARMTargetParser::getArchName(Arch) << '\n';
Saleem Abdulrasool4c4789b2014-01-30 04:46:41 +0000205}
Logan Chien8cbb80d2013-10-28 17:51:12 +0000206void ARMTargetAsmStreamer::emitFPU(unsigned FPU) {
Renato Golinf5f373f2015-05-08 21:04:27 +0000207 OS << "\t.fpu\t" << ARMTargetParser::getFPUName(FPU) << "\n";
Logan Chien8cbb80d2013-10-28 17:51:12 +0000208}
209void ARMTargetAsmStreamer::finishAttributeSection() {
210}
Saleem Abdulrasool56e06e82014-01-30 04:02:47 +0000211void
212ARMTargetAsmStreamer::AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *S) {
213 OS << "\t.tlsdescseq\t" << S->getSymbol().getName();
214}
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000215
Rafael Espindola466d6632014-04-27 20:23:58 +0000216void ARMTargetAsmStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
217 OS << "\t.thumb_set\t" << *Symbol << ", " << *Value << '\n';
218}
219
Saleem Abdulrasoolc0da2cb2013-12-19 05:17:58 +0000220void ARMTargetAsmStreamer::emitInst(uint32_t Inst, char Suffix) {
221 OS << "\t.inst";
222 if (Suffix)
223 OS << "." << Suffix;
Benjamin Kramerbe48c402015-05-23 16:39:10 +0000224 OS << "\t0x" << Twine::utohexstr(Inst) << "\n";
Saleem Abdulrasoolc0da2cb2013-12-19 05:17:58 +0000225}
226
Saleem Abdulrasoold9f08602014-01-21 02:33:10 +0000227void ARMTargetAsmStreamer::emitUnwindRaw(int64_t Offset,
228 const SmallVectorImpl<uint8_t> &Opcodes) {
229 OS << "\t.unwind_raw " << Offset;
230 for (SmallVectorImpl<uint8_t>::const_iterator OCI = Opcodes.begin(),
231 OCE = Opcodes.end();
232 OCI != OCE; ++OCI)
Benjamin Kramerbe48c402015-05-23 16:39:10 +0000233 OS << ", 0x" << Twine::utohexstr(*OCI);
Saleem Abdulrasoold9f08602014-01-21 02:33:10 +0000234 OS << '\n';
235}
236
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000237class ARMTargetELFStreamer : public ARMTargetStreamer {
Logan Chien8cbb80d2013-10-28 17:51:12 +0000238private:
239 // This structure holds all attributes, accounting for
240 // their string/numeric value, so we can later emmit them
241 // in declaration order, keeping all in the same vector
242 struct AttributeItem {
243 enum {
244 HiddenAttribute = 0,
245 NumericAttribute,
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000246 TextAttribute,
247 NumericAndTextAttributes
Logan Chien8cbb80d2013-10-28 17:51:12 +0000248 } Type;
249 unsigned Tag;
250 unsigned IntValue;
251 StringRef StringValue;
252
253 static bool LessTag(const AttributeItem &LHS, const AttributeItem &RHS) {
Charlie Turner8b2caa42015-01-05 13:12:17 +0000254 // The conformance tag must be emitted first when serialised
255 // into an object file. Specifically, the addenda to the ARM ABI
256 // states that (2.3.7.4):
257 //
258 // "To simplify recognition by consumers in the common case of
259 // claiming conformity for the whole file, this tag should be
260 // emitted first in a file-scope sub-subsection of the first
261 // public subsection of the attributes section."
262 //
263 // So it is special-cased in this comparison predicate when the
264 // attributes are sorted in finishAttributeSection().
265 return (RHS.Tag != ARMBuildAttrs::conformance) &&
266 ((LHS.Tag == ARMBuildAttrs::conformance) || (LHS.Tag < RHS.Tag));
Logan Chien8cbb80d2013-10-28 17:51:12 +0000267 }
268 };
269
270 StringRef CurrentVendor;
271 unsigned FPU;
Logan Chien439e8f92013-12-11 17:16:25 +0000272 unsigned Arch;
Saleem Abdulrasool4c4789b2014-01-30 04:46:41 +0000273 unsigned EmittedArch;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000274 SmallVector<AttributeItem, 64> Contents;
275
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000276 MCSection *AttributeSection;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000277
Logan Chien8cbb80d2013-10-28 17:51:12 +0000278 AttributeItem *getAttributeItem(unsigned Attribute) {
279 for (size_t i = 0; i < Contents.size(); ++i)
280 if (Contents[i].Tag == Attribute)
281 return &Contents[i];
Craig Topper062a2ba2014-04-25 05:30:21 +0000282 return nullptr;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000283 }
284
285 void setAttributeItem(unsigned Attribute, unsigned Value,
286 bool OverwriteExisting) {
287 // Look for existing attribute item
288 if (AttributeItem *Item = getAttributeItem(Attribute)) {
289 if (!OverwriteExisting)
290 return;
Saleem Abdulrasool93900052014-01-19 08:25:41 +0000291 Item->Type = AttributeItem::NumericAttribute;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000292 Item->IntValue = Value;
293 return;
294 }
295
296 // Create new attribute item
297 AttributeItem Item = {
298 AttributeItem::NumericAttribute,
299 Attribute,
300 Value,
301 StringRef("")
302 };
303 Contents.push_back(Item);
304 }
305
306 void setAttributeItem(unsigned Attribute, StringRef Value,
307 bool OverwriteExisting) {
308 // Look for existing attribute item
309 if (AttributeItem *Item = getAttributeItem(Attribute)) {
310 if (!OverwriteExisting)
311 return;
Saleem Abdulrasool93900052014-01-19 08:25:41 +0000312 Item->Type = AttributeItem::TextAttribute;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000313 Item->StringValue = Value;
314 return;
315 }
316
317 // Create new attribute item
318 AttributeItem Item = {
319 AttributeItem::TextAttribute,
320 Attribute,
321 0,
322 Value
323 };
324 Contents.push_back(Item);
325 }
326
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000327 void setAttributeItems(unsigned Attribute, unsigned IntValue,
328 StringRef StringValue, bool OverwriteExisting) {
329 // Look for existing attribute item
330 if (AttributeItem *Item = getAttributeItem(Attribute)) {
331 if (!OverwriteExisting)
332 return;
Saleem Abdulrasool93900052014-01-19 08:25:41 +0000333 Item->Type = AttributeItem::NumericAndTextAttributes;
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000334 Item->IntValue = IntValue;
335 Item->StringValue = StringValue;
336 return;
337 }
338
339 // Create new attribute item
340 AttributeItem Item = {
341 AttributeItem::NumericAndTextAttributes,
342 Attribute,
343 IntValue,
344 StringValue
345 };
346 Contents.push_back(Item);
347 }
348
Logan Chien439e8f92013-12-11 17:16:25 +0000349 void emitArchDefaultAttributes();
Logan Chien8cbb80d2013-10-28 17:51:12 +0000350 void emitFPUDefaultAttributes();
351
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000352 ARMELFStreamer &getStreamer();
Logan Chien8cbb80d2013-10-28 17:51:12 +0000353
Craig Topperca7e3e52014-03-10 03:19:03 +0000354 void emitFnStart() override;
355 void emitFnEnd() override;
356 void emitCantUnwind() override;
357 void emitPersonality(const MCSymbol *Personality) override;
358 void emitPersonalityIndex(unsigned Index) override;
359 void emitHandlerData() override;
360 void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
361 void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
362 void emitPad(int64_t Offset) override;
363 void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
364 bool isVector) override;
365 void emitUnwindRaw(int64_t Offset,
366 const SmallVectorImpl<uint8_t> &Opcodes) override;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000367
Craig Topperca7e3e52014-03-10 03:19:03 +0000368 void switchVendor(StringRef Vendor) override;
369 void emitAttribute(unsigned Attribute, unsigned Value) override;
370 void emitTextAttribute(unsigned Attribute, StringRef String) override;
371 void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
372 StringRef StringValue) override;
373 void emitArch(unsigned Arch) override;
374 void emitObjectArch(unsigned Arch) override;
375 void emitFPU(unsigned FPU) override;
376 void emitInst(uint32_t Inst, char Suffix = '\0') override;
377 void finishAttributeSection() override;
Rafael Espindola4c6f6132014-04-27 17:10:46 +0000378 void emitLabel(MCSymbol *Symbol) override;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000379
Craig Topperca7e3e52014-03-10 03:19:03 +0000380 void AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
Rafael Espindola466d6632014-04-27 20:23:58 +0000381 void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
Saleem Abdulrasool56e06e82014-01-30 04:02:47 +0000382
Logan Chien8cbb80d2013-10-28 17:51:12 +0000383 size_t calculateContentSize() const;
384
385public:
Rafael Espindola24ea09e2014-01-26 06:06:37 +0000386 ARMTargetELFStreamer(MCStreamer &S)
Renato Golin35de35d2015-05-12 10:33:58 +0000387 : ARMTargetStreamer(S), CurrentVendor("aeabi"), FPU(ARM::FK_INVALID),
388 Arch(ARM::AK_INVALID), EmittedArch(ARM::AK_INVALID),
Craig Topper062a2ba2014-04-25 05:30:21 +0000389 AttributeSection(nullptr) {}
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000390};
391
Tim Northover5cc3dc82012-12-07 16:50:23 +0000392/// Extend the generic ELFStreamer class so that it can emit mapping symbols at
393/// the appropriate points in the object files. These symbols are defined in the
394/// ARM ELF ABI: infocenter.arm.com/help/topic/com.arm.../IHI0044D_aaelf.pdf.
395///
396/// In brief: $a, $t or $d should be emitted at the start of each contiguous
397/// region of ARM code, Thumb code or data in a section. In practice, this
398/// emission does not rely on explicit assembler directives but on inherent
399/// properties of the directives doing the emission (e.g. ".byte" is data, "add
400/// r0, r0, r0" an instruction).
401///
402/// As a result this system is orthogonal to the DataRegion infrastructure used
403/// by MachO. Beware!
404class ARMELFStreamer : public MCELFStreamer {
405public:
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000406 friend class ARMTargetELFStreamer;
407
Rafael Espindola5560a4c2015-04-14 22:14:34 +0000408 ARMELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
Rafael Espindola24ea09e2014-01-26 06:06:37 +0000409 MCCodeEmitter *Emitter, bool IsThumb)
410 : MCELFStreamer(Context, TAB, OS, Emitter), IsThumb(IsThumb),
411 MappingSymbolCounter(0), LastEMS(EMS_None) {
Logan Chiend8bb4b72013-04-16 12:02:21 +0000412 Reset();
413 }
Tim Northover5cc3dc82012-12-07 16:50:23 +0000414
415 ~ARMELFStreamer() {}
416
Craig Topperca7e3e52014-03-10 03:19:03 +0000417 void FinishImpl() override;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000418
Logan Chien2bcc42c2013-01-30 15:39:04 +0000419 // ARM exception handling directives
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000420 void emitFnStart();
421 void emitFnEnd();
422 void emitCantUnwind();
423 void emitPersonality(const MCSymbol *Per);
Saleem Abdulrasool662f5c12014-01-21 02:33:02 +0000424 void emitPersonalityIndex(unsigned index);
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000425 void emitHandlerData();
426 void emitSetFP(unsigned NewFpReg, unsigned NewSpReg, int64_t Offset = 0);
Saleem Abdulrasool5d962d32014-01-30 04:46:24 +0000427 void emitMovSP(unsigned Reg, int64_t Offset = 0);
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000428 void emitPad(int64_t Offset);
429 void emitRegSave(const SmallVectorImpl<unsigned> &RegList, bool isVector);
Saleem Abdulrasoold9f08602014-01-21 02:33:10 +0000430 void emitUnwindRaw(int64_t Offset, const SmallVectorImpl<uint8_t> &Opcodes);
Logan Chien2bcc42c2013-01-30 15:39:04 +0000431
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000432 void ChangeSection(MCSection *Section, const MCExpr *Subsection) override {
Tim Northover5cc3dc82012-12-07 16:50:23 +0000433 // We have to keep track of the mapping symbol state of any sections we
434 // use. Each one should start off as EMS_None, which is provided as the
435 // default constructor by DenseMap::lookup.
Peter Collingbourne2f495b92013-04-17 21:18:16 +0000436 LastMappingSymbols[getPreviousSection().first] = LastEMS;
Tim Northover5cc3dc82012-12-07 16:50:23 +0000437 LastEMS = LastMappingSymbols.lookup(Section);
438
Peter Collingbourne2f495b92013-04-17 21:18:16 +0000439 MCELFStreamer::ChangeSection(Section, Subsection);
Tim Northover5cc3dc82012-12-07 16:50:23 +0000440 }
441
442 /// This function is the one used to emit instruction data into the ELF
443 /// streamer. We override it to add the appropriate mapping symbol if
444 /// necessary.
Craig Topperca7e3e52014-03-10 03:19:03 +0000445 void EmitInstruction(const MCInst& Inst,
446 const MCSubtargetInfo &STI) override {
Tim Northover5cc3dc82012-12-07 16:50:23 +0000447 if (IsThumb)
448 EmitThumbMappingSymbol();
449 else
450 EmitARMMappingSymbol();
451
David Woodhousee6c13e42014-01-28 23:12:42 +0000452 MCELFStreamer::EmitInstruction(Inst, STI);
Tim Northover5cc3dc82012-12-07 16:50:23 +0000453 }
454
Craig Topperd25ff6f2014-03-10 03:22:59 +0000455 void emitInst(uint32_t Inst, char Suffix) {
Saleem Abdulrasoolc0da2cb2013-12-19 05:17:58 +0000456 unsigned Size;
457 char Buffer[4];
458 const bool LittleEndian = getContext().getAsmInfo()->isLittleEndian();
459
460 switch (Suffix) {
461 case '\0':
462 Size = 4;
463
464 assert(!IsThumb);
465 EmitARMMappingSymbol();
466 for (unsigned II = 0, IE = Size; II != IE; II++) {
467 const unsigned I = LittleEndian ? (Size - II - 1) : II;
468 Buffer[Size - II - 1] = uint8_t(Inst >> I * CHAR_BIT);
469 }
470
471 break;
472 case 'n':
473 case 'w':
474 Size = (Suffix == 'n' ? 2 : 4);
475
476 assert(IsThumb);
477 EmitThumbMappingSymbol();
478 for (unsigned II = 0, IE = Size; II != IE; II = II + 2) {
479 const unsigned I0 = LittleEndian ? II + 0 : (Size - II - 1);
480 const unsigned I1 = LittleEndian ? II + 1 : (Size - II - 2);
481 Buffer[Size - II - 2] = uint8_t(Inst >> I0 * CHAR_BIT);
482 Buffer[Size - II - 1] = uint8_t(Inst >> I1 * CHAR_BIT);
483 }
484
485 break;
486 default:
487 llvm_unreachable("Invalid Suffix");
488 }
489
490 MCELFStreamer::EmitBytes(StringRef(Buffer, Size));
491 }
492
Tim Northover5cc3dc82012-12-07 16:50:23 +0000493 /// This is one of the functions used to emit data into an ELF section, so the
494 /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
495 /// necessary.
Craig Topperca7e3e52014-03-10 03:19:03 +0000496 void EmitBytes(StringRef Data) override {
Tim Northover5cc3dc82012-12-07 16:50:23 +0000497 EmitDataMappingSymbol();
Rafael Espindola64e1af82013-07-02 15:49:13 +0000498 MCELFStreamer::EmitBytes(Data);
Tim Northover5cc3dc82012-12-07 16:50:23 +0000499 }
500
501 /// This is one of the functions used to emit data into an ELF section, so the
502 /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
503 /// necessary.
Kevin Enderby96918bc2014-04-22 17:27:29 +0000504 void EmitValueImpl(const MCExpr *Value, unsigned Size,
505 const SMLoc &Loc) override {
Saleem Abdulrasoolfe781972015-01-11 04:39:18 +0000506 if (const MCSymbolRefExpr *SRE = dyn_cast_or_null<MCSymbolRefExpr>(Value))
507 if (SRE->getKind() == MCSymbolRefExpr::VK_ARM_SBREL && !(Size == 4))
Jim Grosbach6f482002015-05-18 18:43:14 +0000508 getContext().reportFatalError(Loc, "relocated expression must be 32-bit");
Saleem Abdulrasoolfe781972015-01-11 04:39:18 +0000509
Tim Northover5cc3dc82012-12-07 16:50:23 +0000510 EmitDataMappingSymbol();
Rafael Espindola64e1af82013-07-02 15:49:13 +0000511 MCELFStreamer::EmitValueImpl(Value, Size);
Tim Northover5cc3dc82012-12-07 16:50:23 +0000512 }
513
Craig Topperca7e3e52014-03-10 03:19:03 +0000514 void EmitAssemblerFlag(MCAssemblerFlag Flag) override {
Tim Northover5cc3dc82012-12-07 16:50:23 +0000515 MCELFStreamer::EmitAssemblerFlag(Flag);
516
517 switch (Flag) {
518 case MCAF_SyntaxUnified:
519 return; // no-op here.
520 case MCAF_Code16:
521 IsThumb = true;
522 return; // Change to Thumb mode
523 case MCAF_Code32:
524 IsThumb = false;
525 return; // Change to ARM mode
526 case MCAF_Code64:
527 return;
528 case MCAF_SubsectionsViaSymbols:
529 return;
530 }
531 }
532
533private:
534 enum ElfMappingSymbol {
535 EMS_None,
536 EMS_ARM,
537 EMS_Thumb,
538 EMS_Data
539 };
540
541 void EmitDataMappingSymbol() {
542 if (LastEMS == EMS_Data) return;
543 EmitMappingSymbol("$d");
544 LastEMS = EMS_Data;
545 }
546
547 void EmitThumbMappingSymbol() {
548 if (LastEMS == EMS_Thumb) return;
549 EmitMappingSymbol("$t");
550 LastEMS = EMS_Thumb;
551 }
552
553 void EmitARMMappingSymbol() {
554 if (LastEMS == EMS_ARM) return;
555 EmitMappingSymbol("$a");
556 LastEMS = EMS_ARM;
557 }
558
559 void EmitMappingSymbol(StringRef Name) {
Jim Grosbach6f482002015-05-18 18:43:14 +0000560 MCSymbol *Start = getContext().createTempSymbol();
Tim Northover5cc3dc82012-12-07 16:50:23 +0000561 EmitLabel(Start);
562
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000563 auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
564 Name + "." + Twine(MappingSymbolCounter++)));
Tim Northover5cc3dc82012-12-07 16:50:23 +0000565
Rafael Espindolab5d316b2015-05-29 20:21:02 +0000566 getAssembler().registerSymbol(*Symbol);
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000567 Symbol->setType(ELF::STT_NOTYPE);
568 Symbol->setBinding(ELF::STB_LOCAL);
Rafael Espindola4d37b2a2015-05-29 21:45:01 +0000569 Symbol->setExternal(false);
Richard Mitton21101b32013-09-19 23:21:01 +0000570 AssignSection(Symbol, getCurrentSection().first);
Tim Northover5cc3dc82012-12-07 16:50:23 +0000571
Jim Grosbach13760bd2015-05-30 01:25:56 +0000572 const MCExpr *Value = MCSymbolRefExpr::create(Start, getContext());
Tim Northover5cc3dc82012-12-07 16:50:23 +0000573 Symbol->setVariableValue(Value);
574 }
575
Craig Topperca7e3e52014-03-10 03:19:03 +0000576 void EmitThumbFunc(MCSymbol *Func) override {
Tim Northover5cc3dc82012-12-07 16:50:23 +0000577 getAssembler().setIsThumbFunc(Func);
Rafael Espindolab60c8292014-04-29 12:46:50 +0000578 EmitSymbolAttribute(Func, MCSA_ELF_TypeFunction);
Tim Northover5cc3dc82012-12-07 16:50:23 +0000579 }
580
Logan Chien2bcc42c2013-01-30 15:39:04 +0000581 // Helper functions for ARM exception handling directives
582 void Reset();
583
584 void EmitPersonalityFixup(StringRef Name);
Logan Chien325823a2013-06-09 12:22:30 +0000585 void FlushPendingOffset();
Logan Chienc931fce2013-07-02 12:43:27 +0000586 void FlushUnwindOpcodes(bool NoHandlerData);
Logan Chien2bcc42c2013-01-30 15:39:04 +0000587
588 void SwitchToEHSection(const char *Prefix, unsigned Type, unsigned Flags,
589 SectionKind Kind, const MCSymbol &Fn);
590 void SwitchToExTabSection(const MCSymbol &FnStart);
591 void SwitchToExIdxSection(const MCSymbol &FnStart);
Tim Northover5cc3dc82012-12-07 16:50:23 +0000592
Saleem Abdulrasool56e06e82014-01-30 04:02:47 +0000593 void EmitFixup(const MCExpr *Expr, MCFixupKind Kind);
594
Tim Northover5cc3dc82012-12-07 16:50:23 +0000595 bool IsThumb;
596 int64_t MappingSymbolCounter;
597
598 DenseMap<const MCSection *, ElfMappingSymbol> LastMappingSymbols;
599 ElfMappingSymbol LastEMS;
600
Logan Chien2bcc42c2013-01-30 15:39:04 +0000601 // ARM Exception Handling Frame Information
602 MCSymbol *ExTab;
603 MCSymbol *FnStart;
604 const MCSymbol *Personality;
Logan Chien325823a2013-06-09 12:22:30 +0000605 unsigned PersonalityIndex;
606 unsigned FPReg; // Frame pointer register
607 int64_t FPOffset; // Offset: (final frame pointer) - (initial $sp)
608 int64_t SPOffset; // Offset: (final $sp) - (initial $sp)
609 int64_t PendingOffset; // Offset: (final $sp) - (emitted $sp)
Logan Chiend8bb4b72013-04-16 12:02:21 +0000610 bool UsedFP;
Logan Chien2bcc42c2013-01-30 15:39:04 +0000611 bool CantUnwind;
Logan Chien325823a2013-06-09 12:22:30 +0000612 SmallVector<uint8_t, 64> Opcodes;
Logan Chiend8bb4b72013-04-16 12:02:21 +0000613 UnwindOpcodeAssembler UnwindOpAsm;
Tim Northover5cc3dc82012-12-07 16:50:23 +0000614};
Logan Chiend8bb4b72013-04-16 12:02:21 +0000615} // end anonymous namespace
Tim Northover5cc3dc82012-12-07 16:50:23 +0000616
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000617ARMELFStreamer &ARMTargetELFStreamer::getStreamer() {
Rafael Espindola24ea09e2014-01-26 06:06:37 +0000618 return static_cast<ARMELFStreamer &>(Streamer);
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000619}
620
621void ARMTargetELFStreamer::emitFnStart() { getStreamer().emitFnStart(); }
622void ARMTargetELFStreamer::emitFnEnd() { getStreamer().emitFnEnd(); }
623void ARMTargetELFStreamer::emitCantUnwind() { getStreamer().emitCantUnwind(); }
624void ARMTargetELFStreamer::emitPersonality(const MCSymbol *Personality) {
625 getStreamer().emitPersonality(Personality);
626}
Saleem Abdulrasool662f5c12014-01-21 02:33:02 +0000627void ARMTargetELFStreamer::emitPersonalityIndex(unsigned Index) {
628 getStreamer().emitPersonalityIndex(Index);
629}
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000630void ARMTargetELFStreamer::emitHandlerData() {
631 getStreamer().emitHandlerData();
632}
633void ARMTargetELFStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
634 int64_t Offset) {
635 getStreamer().emitSetFP(FpReg, SpReg, Offset);
636}
Saleem Abdulrasool5d962d32014-01-30 04:46:24 +0000637void ARMTargetELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
638 getStreamer().emitMovSP(Reg, Offset);
639}
Rafael Espindolaa17151a2013-10-08 13:08:17 +0000640void ARMTargetELFStreamer::emitPad(int64_t Offset) {
641 getStreamer().emitPad(Offset);
642}
643void ARMTargetELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
644 bool isVector) {
645 getStreamer().emitRegSave(RegList, isVector);
646}
Saleem Abdulrasoold9f08602014-01-21 02:33:10 +0000647void ARMTargetELFStreamer::emitUnwindRaw(int64_t Offset,
648 const SmallVectorImpl<uint8_t> &Opcodes) {
649 getStreamer().emitUnwindRaw(Offset, Opcodes);
650}
Logan Chien8cbb80d2013-10-28 17:51:12 +0000651void ARMTargetELFStreamer::switchVendor(StringRef Vendor) {
652 assert(!Vendor.empty() && "Vendor cannot be empty.");
653
654 if (CurrentVendor == Vendor)
655 return;
656
657 if (!CurrentVendor.empty())
658 finishAttributeSection();
659
660 assert(Contents.empty() &&
661 ".ARM.attributes should be flushed before changing vendor");
662 CurrentVendor = Vendor;
663
664}
665void ARMTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
666 setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
667}
668void ARMTargetELFStreamer::emitTextAttribute(unsigned Attribute,
669 StringRef Value) {
670 setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
671}
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000672void ARMTargetELFStreamer::emitIntTextAttribute(unsigned Attribute,
673 unsigned IntValue,
674 StringRef StringValue) {
675 setAttributeItems(Attribute, IntValue, StringValue,
676 /* OverwriteExisting= */ true);
677}
Logan Chien439e8f92013-12-11 17:16:25 +0000678void ARMTargetELFStreamer::emitArch(unsigned Value) {
679 Arch = Value;
680}
Saleem Abdulrasool4c4789b2014-01-30 04:46:41 +0000681void ARMTargetELFStreamer::emitObjectArch(unsigned Value) {
682 EmittedArch = Value;
683}
Logan Chien439e8f92013-12-11 17:16:25 +0000684void ARMTargetELFStreamer::emitArchDefaultAttributes() {
685 using namespace ARMBuildAttrs;
Saleem Abdulrasool4c4789b2014-01-30 04:46:41 +0000686
Renato Golinf5f373f2015-05-08 21:04:27 +0000687 setAttributeItem(CPU_name,
Renato Golinf7c0d5f2015-05-27 18:15:37 +0000688 ARMTargetParser::getCPUAttr(Arch),
Renato Golinf5f373f2015-05-08 21:04:27 +0000689 false);
690
Renato Golin35de35d2015-05-12 10:33:58 +0000691 if (EmittedArch == ARM::AK_INVALID)
Renato Golinf5f373f2015-05-08 21:04:27 +0000692 setAttributeItem(CPU_arch,
Renato Golinf7c0d5f2015-05-27 18:15:37 +0000693 ARMTargetParser::getArchAttr(Arch),
Renato Golinf5f373f2015-05-08 21:04:27 +0000694 false);
Saleem Abdulrasool4c4789b2014-01-30 04:46:41 +0000695 else
Renato Golinf5f373f2015-05-08 21:04:27 +0000696 setAttributeItem(CPU_arch,
Renato Golinf7c0d5f2015-05-27 18:15:37 +0000697 ARMTargetParser::getArchAttr(EmittedArch),
Renato Golinf5f373f2015-05-08 21:04:27 +0000698 false);
Logan Chien439e8f92013-12-11 17:16:25 +0000699
700 switch (Arch) {
Renato Golin35de35d2015-05-12 10:33:58 +0000701 case ARM::AK_ARMV2:
702 case ARM::AK_ARMV2A:
703 case ARM::AK_ARMV3:
704 case ARM::AK_ARMV3M:
705 case ARM::AK_ARMV4:
706 case ARM::AK_ARMV5:
Logan Chien439e8f92013-12-11 17:16:25 +0000707 setAttributeItem(ARM_ISA_use, Allowed, false);
708 break;
709
Renato Golin35de35d2015-05-12 10:33:58 +0000710 case ARM::AK_ARMV4T:
711 case ARM::AK_ARMV5T:
712 case ARM::AK_ARMV5TE:
713 case ARM::AK_ARMV6:
714 case ARM::AK_ARMV6J:
Logan Chien439e8f92013-12-11 17:16:25 +0000715 setAttributeItem(ARM_ISA_use, Allowed, false);
716 setAttributeItem(THUMB_ISA_use, Allowed, false);
717 break;
718
Renato Golin35de35d2015-05-12 10:33:58 +0000719 case ARM::AK_ARMV6T2:
Logan Chien439e8f92013-12-11 17:16:25 +0000720 setAttributeItem(ARM_ISA_use, Allowed, false);
721 setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
722 break;
723
Renato Golin35de35d2015-05-12 10:33:58 +0000724 case ARM::AK_ARMV6K:
725 case ARM::AK_ARMV6Z:
726 case ARM::AK_ARMV6ZK:
Logan Chien439e8f92013-12-11 17:16:25 +0000727 setAttributeItem(ARM_ISA_use, Allowed, false);
728 setAttributeItem(THUMB_ISA_use, Allowed, false);
729 setAttributeItem(Virtualization_use, AllowTZ, false);
730 break;
731
Renato Golin35de35d2015-05-12 10:33:58 +0000732 case ARM::AK_ARMV6M:
Logan Chien439e8f92013-12-11 17:16:25 +0000733 setAttributeItem(THUMB_ISA_use, Allowed, false);
734 break;
735
Renato Golin35de35d2015-05-12 10:33:58 +0000736 case ARM::AK_ARMV7:
Logan Chien439e8f92013-12-11 17:16:25 +0000737 setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
738 break;
739
Renato Golin35de35d2015-05-12 10:33:58 +0000740 case ARM::AK_ARMV7A:
Logan Chien439e8f92013-12-11 17:16:25 +0000741 setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
742 setAttributeItem(ARM_ISA_use, Allowed, false);
743 setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
744 break;
745
Renato Golin35de35d2015-05-12 10:33:58 +0000746 case ARM::AK_ARMV7R:
Logan Chien439e8f92013-12-11 17:16:25 +0000747 setAttributeItem(CPU_arch_profile, RealTimeProfile, false);
748 setAttributeItem(ARM_ISA_use, Allowed, false);
749 setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
750 break;
751
Renato Golin35de35d2015-05-12 10:33:58 +0000752 case ARM::AK_ARMV7M:
Logan Chien439e8f92013-12-11 17:16:25 +0000753 setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
754 setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
755 break;
756
Renato Golin35de35d2015-05-12 10:33:58 +0000757 case ARM::AK_ARMV8A:
758 case ARM::AK_ARMV8_1A:
Logan Chien439e8f92013-12-11 17:16:25 +0000759 setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
760 setAttributeItem(ARM_ISA_use, Allowed, false);
761 setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
762 setAttributeItem(MPextension_use, Allowed, false);
763 setAttributeItem(Virtualization_use, AllowTZVirtualization, false);
764 break;
765
Renato Golin35de35d2015-05-12 10:33:58 +0000766 case ARM::AK_IWMMXT:
Logan Chien439e8f92013-12-11 17:16:25 +0000767 setAttributeItem(ARM_ISA_use, Allowed, false);
768 setAttributeItem(THUMB_ISA_use, Allowed, false);
769 setAttributeItem(WMMX_arch, AllowWMMXv1, false);
770 break;
771
Renato Golin35de35d2015-05-12 10:33:58 +0000772 case ARM::AK_IWMMXT2:
Logan Chien439e8f92013-12-11 17:16:25 +0000773 setAttributeItem(ARM_ISA_use, Allowed, false);
774 setAttributeItem(THUMB_ISA_use, Allowed, false);
775 setAttributeItem(WMMX_arch, AllowWMMXv2, false);
776 break;
777
778 default:
779 report_fatal_error("Unknown Arch: " + Twine(Arch));
780 break;
781 }
782}
Logan Chien8cbb80d2013-10-28 17:51:12 +0000783void ARMTargetELFStreamer::emitFPU(unsigned Value) {
784 FPU = Value;
785}
786void ARMTargetELFStreamer::emitFPUDefaultAttributes() {
787 switch (FPU) {
Renato Golin35de35d2015-05-12 10:33:58 +0000788 case ARM::FK_VFP:
789 case ARM::FK_VFPV2:
Logan Chiena39510a2013-12-18 17:23:15 +0000790 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000791 ARMBuildAttrs::AllowFPv2,
792 /* OverwriteExisting= */ false);
793 break;
794
Renato Golin35de35d2015-05-12 10:33:58 +0000795 case ARM::FK_VFPV3:
Logan Chiena39510a2013-12-18 17:23:15 +0000796 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000797 ARMBuildAttrs::AllowFPv3A,
798 /* OverwriteExisting= */ false);
799 break;
800
Renato Golin35de35d2015-05-12 10:33:58 +0000801 case ARM::FK_VFPV3_D16:
Logan Chiena39510a2013-12-18 17:23:15 +0000802 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000803 ARMBuildAttrs::AllowFPv3B,
804 /* OverwriteExisting= */ false);
805 break;
806
Renato Golin35de35d2015-05-12 10:33:58 +0000807 case ARM::FK_VFPV4:
Logan Chiena39510a2013-12-18 17:23:15 +0000808 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000809 ARMBuildAttrs::AllowFPv4A,
810 /* OverwriteExisting= */ false);
811 break;
812
Renato Golin35de35d2015-05-12 10:33:58 +0000813 case ARM::FK_VFPV4_D16:
Logan Chiena39510a2013-12-18 17:23:15 +0000814 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000815 ARMBuildAttrs::AllowFPv4B,
816 /* OverwriteExisting= */ false);
817 break;
818
Renato Golin35de35d2015-05-12 10:33:58 +0000819 case ARM::FK_FP_ARMV8:
Logan Chiena39510a2013-12-18 17:23:15 +0000820 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000821 ARMBuildAttrs::AllowFPARMv8A,
822 /* OverwriteExisting= */ false);
823 break;
824
Oliver Stannard37e4daa2014-10-01 09:02:17 +0000825 // FPV5_D16 is identical to FP_ARMV8 except for the number of D registers, so
826 // uses the FP_ARMV8_D16 build attribute.
Renato Golin35de35d2015-05-12 10:33:58 +0000827 case ARM::FK_FPV5_D16:
Oliver Stannard37e4daa2014-10-01 09:02:17 +0000828 setAttributeItem(ARMBuildAttrs::FP_arch,
829 ARMBuildAttrs::AllowFPARMv8B,
830 /* OverwriteExisting= */ false);
831 break;
832
Renato Golin35de35d2015-05-12 10:33:58 +0000833 case ARM::FK_NEON:
Logan Chiena39510a2013-12-18 17:23:15 +0000834 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000835 ARMBuildAttrs::AllowFPv3A,
836 /* OverwriteExisting= */ false);
837 setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
838 ARMBuildAttrs::AllowNeon,
839 /* OverwriteExisting= */ false);
840 break;
841
Renato Golin35de35d2015-05-12 10:33:58 +0000842 case ARM::FK_NEON_VFPV4:
Logan Chiena39510a2013-12-18 17:23:15 +0000843 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000844 ARMBuildAttrs::AllowFPv4A,
845 /* OverwriteExisting= */ false);
846 setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
847 ARMBuildAttrs::AllowNeon2,
848 /* OverwriteExisting= */ false);
849 break;
850
Renato Golin35de35d2015-05-12 10:33:58 +0000851 case ARM::FK_NEON_FP_ARMV8:
852 case ARM::FK_CRYPTO_NEON_FP_ARMV8:
Logan Chiena39510a2013-12-18 17:23:15 +0000853 setAttributeItem(ARMBuildAttrs::FP_arch,
Logan Chien8cbb80d2013-10-28 17:51:12 +0000854 ARMBuildAttrs::AllowFPARMv8A,
855 /* OverwriteExisting= */ false);
Vladimir Sukharevc632cda2015-03-26 17:05:54 +0000856 // 'Advanced_SIMD_arch' must be emitted not here, but within
857 // ARMAsmPrinter::emitAttributes(), depending on hasV8Ops() and hasV8_1a()
Logan Chien8cbb80d2013-10-28 17:51:12 +0000858 break;
859
Renato Golin35de35d2015-05-12 10:33:58 +0000860 case ARM::FK_SOFTVFP:
Logan Chien05ae7442014-01-02 15:50:02 +0000861 break;
862
Logan Chien8cbb80d2013-10-28 17:51:12 +0000863 default:
864 report_fatal_error("Unknown FPU: " + Twine(FPU));
865 break;
866 }
867}
868size_t ARMTargetELFStreamer::calculateContentSize() const {
869 size_t Result = 0;
870 for (size_t i = 0; i < Contents.size(); ++i) {
871 AttributeItem item = Contents[i];
872 switch (item.Type) {
873 case AttributeItem::HiddenAttribute:
874 break;
875 case AttributeItem::NumericAttribute:
Logan Chien5b776b72014-02-22 14:00:39 +0000876 Result += getULEB128Size(item.Tag);
877 Result += getULEB128Size(item.IntValue);
Logan Chien8cbb80d2013-10-28 17:51:12 +0000878 break;
879 case AttributeItem::TextAttribute:
Logan Chien5b776b72014-02-22 14:00:39 +0000880 Result += getULEB128Size(item.Tag);
Logan Chien8cbb80d2013-10-28 17:51:12 +0000881 Result += item.StringValue.size() + 1; // string + '\0'
882 break;
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000883 case AttributeItem::NumericAndTextAttributes:
Logan Chien5b776b72014-02-22 14:00:39 +0000884 Result += getULEB128Size(item.Tag);
885 Result += getULEB128Size(item.IntValue);
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000886 Result += item.StringValue.size() + 1; // string + '\0';
887 break;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000888 }
889 }
890 return Result;
891}
892void ARMTargetELFStreamer::finishAttributeSection() {
893 // <format-version>
894 // [ <section-length> "vendor-name"
895 // [ <file-tag> <size> <attribute>*
896 // | <section-tag> <size> <section-number>* 0 <attribute>*
897 // | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
898 // ]+
899 // ]*
900
Renato Golin35de35d2015-05-12 10:33:58 +0000901 if (FPU != ARM::FK_INVALID)
Logan Chien8cbb80d2013-10-28 17:51:12 +0000902 emitFPUDefaultAttributes();
903
Renato Golin35de35d2015-05-12 10:33:58 +0000904 if (Arch != ARM::AK_INVALID)
Logan Chien439e8f92013-12-11 17:16:25 +0000905 emitArchDefaultAttributes();
906
Logan Chien8cbb80d2013-10-28 17:51:12 +0000907 if (Contents.empty())
908 return;
909
910 std::sort(Contents.begin(), Contents.end(), AttributeItem::LessTag);
911
912 ARMELFStreamer &Streamer = getStreamer();
913
914 // Switch to .ARM.attributes section
915 if (AttributeSection) {
916 Streamer.SwitchSection(AttributeSection);
917 } else {
Rafael Espindolaba31e272015-01-29 17:33:21 +0000918 AttributeSection = Streamer.getContext().getELFSection(
919 ".ARM.attributes", ELF::SHT_ARM_ATTRIBUTES, 0);
Logan Chien8cbb80d2013-10-28 17:51:12 +0000920 Streamer.SwitchSection(AttributeSection);
921
922 // Format version
923 Streamer.EmitIntValue(0x41, 1);
924 }
925
926 // Vendor size + Vendor name + '\0'
927 const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;
928
929 // Tag + Tag Size
930 const size_t TagHeaderSize = 1 + 4;
931
932 const size_t ContentsSize = calculateContentSize();
933
934 Streamer.EmitIntValue(VendorHeaderSize + TagHeaderSize + ContentsSize, 4);
935 Streamer.EmitBytes(CurrentVendor);
936 Streamer.EmitIntValue(0, 1); // '\0'
937
938 Streamer.EmitIntValue(ARMBuildAttrs::File, 1);
939 Streamer.EmitIntValue(TagHeaderSize + ContentsSize, 4);
940
941 // Size should have been accounted for already, now
942 // emit each field as its type (ULEB or String)
943 for (size_t i = 0; i < Contents.size(); ++i) {
944 AttributeItem item = Contents[i];
945 Streamer.EmitULEB128IntValue(item.Tag);
946 switch (item.Type) {
947 default: llvm_unreachable("Invalid attribute type");
948 case AttributeItem::NumericAttribute:
949 Streamer.EmitULEB128IntValue(item.IntValue);
950 break;
951 case AttributeItem::TextAttribute:
Charlie Turner8d433692014-11-27 12:13:56 +0000952 Streamer.EmitBytes(item.StringValue);
Logan Chien8cbb80d2013-10-28 17:51:12 +0000953 Streamer.EmitIntValue(0, 1); // '\0'
954 break;
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000955 case AttributeItem::NumericAndTextAttributes:
956 Streamer.EmitULEB128IntValue(item.IntValue);
Charlie Turner8d433692014-11-27 12:13:56 +0000957 Streamer.EmitBytes(item.StringValue);
Saleem Abdulrasool87ccd362014-01-07 02:28:42 +0000958 Streamer.EmitIntValue(0, 1); // '\0'
959 break;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000960 }
961 }
962
963 Contents.clear();
Renato Golin35de35d2015-05-12 10:33:58 +0000964 FPU = ARM::FK_INVALID;
Logan Chien8cbb80d2013-10-28 17:51:12 +0000965}
Rafael Espindola4c6f6132014-04-27 17:10:46 +0000966
967void ARMTargetELFStreamer::emitLabel(MCSymbol *Symbol) {
968 ARMELFStreamer &Streamer = getStreamer();
969 if (!Streamer.IsThumb)
970 return;
971
Rafael Espindolac73aed12015-06-03 19:03:11 +0000972 Streamer.getAssembler().registerSymbol(*Symbol);
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000973 unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
Rafael Espindolaf8794ff2015-06-04 00:47:43 +0000974 if (Type == ELF::STT_FUNC || Type == ELF::STT_GNU_IFUNC)
Rafael Espindola4c6f6132014-04-27 17:10:46 +0000975 Streamer.EmitThumbFunc(Symbol);
976}
977
Saleem Abdulrasool56e06e82014-01-30 04:02:47 +0000978void
979ARMTargetELFStreamer::AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *S) {
980 getStreamer().EmitFixup(S, FK_Data_4);
981}
Rafael Espindola466d6632014-04-27 20:23:58 +0000982
983void ARMTargetELFStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
984 if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(Value)) {
Rafael Espindola4a042942014-05-01 12:45:43 +0000985 const MCSymbol &Sym = SRE->getSymbol();
986 if (!Sym.isDefined()) {
Rafael Espindola466d6632014-04-27 20:23:58 +0000987 getStreamer().EmitAssignment(Symbol, Value);
988 return;
989 }
990 }
991
992 getStreamer().EmitThumbFunc(Symbol);
993 getStreamer().EmitAssignment(Symbol, Value);
994}
995
Saleem Abdulrasoolc0da2cb2013-12-19 05:17:58 +0000996void ARMTargetELFStreamer::emitInst(uint32_t Inst, char Suffix) {
997 getStreamer().emitInst(Inst, Suffix);
998}
Logan Chien8cbb80d2013-10-28 17:51:12 +0000999
1000void ARMELFStreamer::FinishImpl() {
Rafael Espindola4a1a3602014-01-14 01:21:46 +00001001 MCTargetStreamer &TS = *getTargetStreamer();
Logan Chien8cbb80d2013-10-28 17:51:12 +00001002 ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
1003 ATS.finishAttributeSection();
1004
1005 MCELFStreamer::FinishImpl();
1006}
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001007
Logan Chien2bcc42c2013-01-30 15:39:04 +00001008inline void ARMELFStreamer::SwitchToEHSection(const char *Prefix,
1009 unsigned Type,
1010 unsigned Flags,
1011 SectionKind Kind,
1012 const MCSymbol &Fn) {
1013 const MCSectionELF &FnSection =
1014 static_cast<const MCSectionELF &>(Fn.getSection());
1015
1016 // Create the name for new section
1017 StringRef FnSecName(FnSection.getSectionName());
1018 SmallString<128> EHSecName(Prefix);
1019 if (FnSecName != ".text") {
1020 EHSecName += FnSecName;
1021 }
1022
1023 // Get .ARM.extab or .ARM.exidx section
Rafael Espindola0ccf9b72015-06-02 21:30:13 +00001024 const MCSymbolELF *Group = FnSection.getGroup();
Rafael Espindola61e8ce32015-04-06 04:25:18 +00001025 if (Group)
1026 Flags |= ELF::SHF_GROUP;
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001027 MCSectionELF *EHSection =
Rafael Espindola61e8ce32015-04-06 04:25:18 +00001028 getContext().getELFSection(EHSecName, Type, Flags, 0, Group,
1029 FnSection.getUniqueID(), nullptr, &FnSection);
1030
Logan Chiend8bb4b72013-04-16 12:02:21 +00001031 assert(EHSection && "Failed to get the required EH section");
Logan Chien2bcc42c2013-01-30 15:39:04 +00001032
1033 // Switch to .ARM.extab or .ARM.exidx section
1034 SwitchSection(EHSection);
Rafael Espindola7b514962014-02-04 18:34:04 +00001035 EmitCodeAlignment(4);
Logan Chien2bcc42c2013-01-30 15:39:04 +00001036}
1037
1038inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
1039 SwitchToEHSection(".ARM.extab",
1040 ELF::SHT_PROGBITS,
1041 ELF::SHF_ALLOC,
1042 SectionKind::getDataRel(),
1043 FnStart);
1044}
1045
1046inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
1047 SwitchToEHSection(".ARM.exidx",
1048 ELF::SHT_ARM_EXIDX,
1049 ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER,
1050 SectionKind::getDataRel(),
1051 FnStart);
1052}
Saleem Abdulrasool56e06e82014-01-30 04:02:47 +00001053void ARMELFStreamer::EmitFixup(const MCExpr *Expr, MCFixupKind Kind) {
1054 MCDataFragment *Frag = getOrCreateDataFragment();
Jim Grosbach63661f82015-05-15 19:13:05 +00001055 Frag->getFixups().push_back(MCFixup::create(Frag->getContents().size(), Expr,
Saleem Abdulrasool56e06e82014-01-30 04:02:47 +00001056 Kind));
1057}
Logan Chien2bcc42c2013-01-30 15:39:04 +00001058
1059void ARMELFStreamer::Reset() {
Craig Topper062a2ba2014-04-25 05:30:21 +00001060 ExTab = nullptr;
1061 FnStart = nullptr;
1062 Personality = nullptr;
Saleem Abdulrasoolb961c992014-01-06 00:15:00 +00001063 PersonalityIndex = ARM::EHABI::NUM_PERSONALITY_INDEX;
Logan Chien325823a2013-06-09 12:22:30 +00001064 FPReg = ARM::SP;
Logan Chiend8bb4b72013-04-16 12:02:21 +00001065 FPOffset = 0;
1066 SPOffset = 0;
Logan Chien325823a2013-06-09 12:22:30 +00001067 PendingOffset = 0;
Logan Chiend8bb4b72013-04-16 12:02:21 +00001068 UsedFP = false;
Logan Chien2bcc42c2013-01-30 15:39:04 +00001069 CantUnwind = false;
Logan Chiend8bb4b72013-04-16 12:02:21 +00001070
Logan Chien325823a2013-06-09 12:22:30 +00001071 Opcodes.clear();
Logan Chiend8bb4b72013-04-16 12:02:21 +00001072 UnwindOpAsm.Reset();
Logan Chien2bcc42c2013-01-30 15:39:04 +00001073}
1074
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001075void ARMELFStreamer::emitFnStart() {
Craig Toppere73658d2014-04-28 04:05:08 +00001076 assert(FnStart == nullptr);
Jim Grosbach6f482002015-05-18 18:43:14 +00001077 FnStart = getContext().createTempSymbol();
Logan Chien2bcc42c2013-01-30 15:39:04 +00001078 EmitLabel(FnStart);
1079}
1080
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001081void ARMELFStreamer::emitFnEnd() {
Alp Tokercb402912014-01-24 17:20:08 +00001082 assert(FnStart && ".fnstart must precedes .fnend");
Logan Chien2bcc42c2013-01-30 15:39:04 +00001083
1084 // Emit unwind opcodes if there is no .handlerdata directive
Logan Chien4ea23b52013-05-10 16:17:24 +00001085 if (!ExTab && !CantUnwind)
1086 FlushUnwindOpcodes(true);
Logan Chien2bcc42c2013-01-30 15:39:04 +00001087
1088 // Emit the exception index table entry
1089 SwitchToExIdxSection(*FnStart);
1090
Saleem Abdulrasoolb961c992014-01-06 00:15:00 +00001091 if (PersonalityIndex < ARM::EHABI::NUM_PERSONALITY_INDEX)
Logan Chiend8bb4b72013-04-16 12:02:21 +00001092 EmitPersonalityFixup(GetAEABIUnwindPersonalityName(PersonalityIndex));
Logan Chien2bcc42c2013-01-30 15:39:04 +00001093
1094 const MCSymbolRefExpr *FnStartRef =
Jim Grosbach13760bd2015-05-30 01:25:56 +00001095 MCSymbolRefExpr::create(FnStart,
Logan Chien2bcc42c2013-01-30 15:39:04 +00001096 MCSymbolRefExpr::VK_ARM_PREL31,
1097 getContext());
1098
Rafael Espindola64e1af82013-07-02 15:49:13 +00001099 EmitValue(FnStartRef, 4);
Logan Chien2bcc42c2013-01-30 15:39:04 +00001100
1101 if (CantUnwind) {
Saleem Abdulrasoolb961c992014-01-06 00:15:00 +00001102 EmitIntValue(ARM::EHABI::EXIDX_CANTUNWIND, 4);
Logan Chiend8bb4b72013-04-16 12:02:21 +00001103 } else if (ExTab) {
1104 // Emit a reference to the unwind opcodes in the ".ARM.extab" section.
Logan Chien2bcc42c2013-01-30 15:39:04 +00001105 const MCSymbolRefExpr *ExTabEntryRef =
Jim Grosbach13760bd2015-05-30 01:25:56 +00001106 MCSymbolRefExpr::create(ExTab,
Logan Chien2bcc42c2013-01-30 15:39:04 +00001107 MCSymbolRefExpr::VK_ARM_PREL31,
1108 getContext());
Rafael Espindola64e1af82013-07-02 15:49:13 +00001109 EmitValue(ExTabEntryRef, 4);
Logan Chiend8bb4b72013-04-16 12:02:21 +00001110 } else {
1111 // For the __aeabi_unwind_cpp_pr0, we have to emit the unwind opcodes in
1112 // the second word of exception index table entry. The size of the unwind
1113 // opcodes should always be 4 bytes.
Saleem Abdulrasoolb961c992014-01-06 00:15:00 +00001114 assert(PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0 &&
Jonathan Roelofs4971b402014-05-15 02:24:50 +00001115 "Compact model must use __aeabi_unwind_cpp_pr0 as personality");
Logan Chien325823a2013-06-09 12:22:30 +00001116 assert(Opcodes.size() == 4u &&
Jonathan Roelofs4971b402014-05-15 02:24:50 +00001117 "Unwind opcode size for __aeabi_unwind_cpp_pr0 must be equal to 4");
Christian Pirker39db7ec2014-05-13 16:44:30 +00001118 uint64_t Intval = Opcodes[0] |
1119 Opcodes[1] << 8 |
1120 Opcodes[2] << 16 |
1121 Opcodes[3] << 24;
1122 EmitIntValue(Intval, Opcodes.size());
Logan Chien2bcc42c2013-01-30 15:39:04 +00001123 }
1124
Logan Chien4ea23b52013-05-10 16:17:24 +00001125 // Switch to the section containing FnStart
1126 SwitchSection(&FnStart->getSection());
1127
Logan Chien2bcc42c2013-01-30 15:39:04 +00001128 // Clean exception handling frame information
1129 Reset();
1130}
1131
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001132void ARMELFStreamer::emitCantUnwind() { CantUnwind = true; }
1133
1134// Add the R_ARM_NONE fixup at the same position
1135void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
Jim Grosbach6f482002015-05-18 18:43:14 +00001136 const MCSymbol *PersonalitySym = getContext().getOrCreateSymbol(Name);
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001137
Jim Grosbach13760bd2015-05-30 01:25:56 +00001138 const MCSymbolRefExpr *PersonalityRef = MCSymbolRefExpr::create(
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001139 PersonalitySym, MCSymbolRefExpr::VK_ARM_NONE, getContext());
1140
Rafael Espindola2be12812014-06-25 15:29:54 +00001141 visitUsedExpr(*PersonalityRef);
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001142 MCDataFragment *DF = getOrCreateDataFragment();
Jim Grosbach63661f82015-05-15 19:13:05 +00001143 DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001144 PersonalityRef,
1145 MCFixup::getKindForSize(4, false)));
Logan Chien2bcc42c2013-01-30 15:39:04 +00001146}
1147
Logan Chien325823a2013-06-09 12:22:30 +00001148void ARMELFStreamer::FlushPendingOffset() {
1149 if (PendingOffset != 0) {
1150 UnwindOpAsm.EmitSPOffset(-PendingOffset);
1151 PendingOffset = 0;
1152 }
1153}
1154
Logan Chienc931fce2013-07-02 12:43:27 +00001155void ARMELFStreamer::FlushUnwindOpcodes(bool NoHandlerData) {
Logan Chien325823a2013-06-09 12:22:30 +00001156 // Emit the unwind opcode to restore $sp.
1157 if (UsedFP) {
Bill Wendlingbc07a892013-06-18 07:20:20 +00001158 const MCRegisterInfo *MRI = getContext().getRegisterInfo();
Logan Chien325823a2013-06-09 12:22:30 +00001159 int64_t LastRegSaveSPOffset = SPOffset - PendingOffset;
1160 UnwindOpAsm.EmitSPOffset(LastRegSaveSPOffset - FPOffset);
Bill Wendlingbc07a892013-06-18 07:20:20 +00001161 UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
Logan Chien325823a2013-06-09 12:22:30 +00001162 } else {
1163 FlushPendingOffset();
1164 }
1165
1166 // Finalize the unwind opcode sequence
1167 UnwindOpAsm.Finalize(PersonalityIndex, Opcodes);
Logan Chien4ea23b52013-05-10 16:17:24 +00001168
1169 // For compact model 0, we have to emit the unwind opcodes in the .ARM.exidx
1170 // section. Thus, we don't have to create an entry in the .ARM.extab
1171 // section.
Saleem Abdulrasoolb961c992014-01-06 00:15:00 +00001172 if (NoHandlerData && PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0)
Logan Chien4ea23b52013-05-10 16:17:24 +00001173 return;
1174
1175 // Switch to .ARM.extab section.
Logan Chien2bcc42c2013-01-30 15:39:04 +00001176 SwitchToExTabSection(*FnStart);
1177
1178 // Create .ARM.extab label for offset in .ARM.exidx
1179 assert(!ExTab);
Jim Grosbach6f482002015-05-18 18:43:14 +00001180 ExTab = getContext().createTempSymbol();
Logan Chien2bcc42c2013-01-30 15:39:04 +00001181 EmitLabel(ExTab);
1182
Logan Chien4ea23b52013-05-10 16:17:24 +00001183 // Emit personality
1184 if (Personality) {
1185 const MCSymbolRefExpr *PersonalityRef =
Jim Grosbach13760bd2015-05-30 01:25:56 +00001186 MCSymbolRefExpr::create(Personality,
Logan Chien4ea23b52013-05-10 16:17:24 +00001187 MCSymbolRefExpr::VK_ARM_PREL31,
1188 getContext());
Logan Chien2bcc42c2013-01-30 15:39:04 +00001189
Rafael Espindola64e1af82013-07-02 15:49:13 +00001190 EmitValue(PersonalityRef, 4);
Logan Chien4ea23b52013-05-10 16:17:24 +00001191 }
Logan Chien2bcc42c2013-01-30 15:39:04 +00001192
1193 // Emit unwind opcodes
Christian Pirker39db7ec2014-05-13 16:44:30 +00001194 assert((Opcodes.size() % 4) == 0 &&
1195 "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be multiple of 4");
1196 for (unsigned I = 0; I != Opcodes.size(); I += 4) {
1197 uint64_t Intval = Opcodes[I] |
1198 Opcodes[I + 1] << 8 |
1199 Opcodes[I + 2] << 16 |
1200 Opcodes[I + 3] << 24;
1201 EmitIntValue(Intval, 4);
1202 }
Logan Chienc931fce2013-07-02 12:43:27 +00001203
1204 // According to ARM EHABI section 9.2, if the __aeabi_unwind_cpp_pr1() or
1205 // __aeabi_unwind_cpp_pr2() is used, then the handler data must be emitted
1206 // after the unwind opcodes. The handler data consists of several 32-bit
1207 // words, and should be terminated by zero.
1208 //
1209 // In case that the .handlerdata directive is not specified by the
1210 // programmer, we should emit zero to terminate the handler data.
1211 if (NoHandlerData && !Personality)
1212 EmitIntValue(0, 4);
Logan Chien2bcc42c2013-01-30 15:39:04 +00001213}
1214
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001215void ARMELFStreamer::emitHandlerData() { FlushUnwindOpcodes(false); }
Logan Chien4ea23b52013-05-10 16:17:24 +00001216
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001217void ARMELFStreamer::emitPersonality(const MCSymbol *Per) {
Logan Chien2bcc42c2013-01-30 15:39:04 +00001218 Personality = Per;
Logan Chiend8bb4b72013-04-16 12:02:21 +00001219 UnwindOpAsm.setPersonality(Per);
Logan Chien2bcc42c2013-01-30 15:39:04 +00001220}
1221
Saleem Abdulrasool662f5c12014-01-21 02:33:02 +00001222void ARMELFStreamer::emitPersonalityIndex(unsigned Index) {
1223 assert(Index < ARM::EHABI::NUM_PERSONALITY_INDEX && "invalid index");
1224 PersonalityIndex = Index;
1225}
1226
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001227void ARMELFStreamer::emitSetFP(unsigned NewFPReg, unsigned NewSPReg,
Logan Chien2bcc42c2013-01-30 15:39:04 +00001228 int64_t Offset) {
Logan Chien325823a2013-06-09 12:22:30 +00001229 assert((NewSPReg == ARM::SP || NewSPReg == FPReg) &&
Logan Chiend8bb4b72013-04-16 12:02:21 +00001230 "the operand of .setfp directive should be either $sp or $fp");
1231
1232 UsedFP = true;
Logan Chien325823a2013-06-09 12:22:30 +00001233 FPReg = NewFPReg;
1234
1235 if (NewSPReg == ARM::SP)
1236 FPOffset = SPOffset + Offset;
1237 else
1238 FPOffset += Offset;
Logan Chien2bcc42c2013-01-30 15:39:04 +00001239}
1240
Saleem Abdulrasool5d962d32014-01-30 04:46:24 +00001241void ARMELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
1242 assert((Reg != ARM::SP && Reg != ARM::PC) &&
1243 "the operand of .movsp cannot be either sp or pc");
1244 assert(FPReg == ARM::SP && "current FP must be SP");
1245
1246 FlushPendingOffset();
1247
1248 FPReg = Reg;
1249 FPOffset = SPOffset + Offset;
1250
1251 const MCRegisterInfo *MRI = getContext().getRegisterInfo();
1252 UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
1253}
1254
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001255void ARMELFStreamer::emitPad(int64_t Offset) {
Logan Chien325823a2013-06-09 12:22:30 +00001256 // Track the change of the $sp offset
1257 SPOffset -= Offset;
1258
1259 // To squash multiple .pad directives, we should delay the unwind opcode
1260 // until the .save, .vsave, .handlerdata, or .fnend directives.
1261 PendingOffset -= Offset;
Logan Chien2bcc42c2013-01-30 15:39:04 +00001262}
1263
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001264void ARMELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
Logan Chien2bcc42c2013-01-30 15:39:04 +00001265 bool IsVector) {
Logan Chien325823a2013-06-09 12:22:30 +00001266 // Collect the registers in the register list
1267 unsigned Count = 0;
1268 uint32_t Mask = 0;
Bill Wendlingbc07a892013-06-18 07:20:20 +00001269 const MCRegisterInfo *MRI = getContext().getRegisterInfo();
Logan Chiend8bb4b72013-04-16 12:02:21 +00001270 for (size_t i = 0; i < RegList.size(); ++i) {
Bill Wendlingbc07a892013-06-18 07:20:20 +00001271 unsigned Reg = MRI->getEncodingValue(RegList[i]);
Aaron Ballmanab1d27e2013-06-10 16:45:40 +00001272 assert(Reg < (IsVector ? 32U : 16U) && "Register out of range");
Logan Chien325823a2013-06-09 12:22:30 +00001273 unsigned Bit = (1u << Reg);
1274 if ((Mask & Bit) == 0) {
1275 Mask |= Bit;
1276 ++Count;
1277 }
Logan Chiend8bb4b72013-04-16 12:02:21 +00001278 }
Logan Chien325823a2013-06-09 12:22:30 +00001279
1280 // Track the change the $sp offset: For the .save directive, the
1281 // corresponding push instruction will decrease the $sp by (4 * Count).
1282 // For the .vsave directive, the corresponding vpush instruction will
1283 // decrease $sp by (8 * Count).
1284 SPOffset -= Count * (IsVector ? 8 : 4);
1285
1286 // Emit the opcode
1287 FlushPendingOffset();
1288 if (IsVector)
1289 UnwindOpAsm.EmitVFPRegSave(Mask);
1290 else
1291 UnwindOpAsm.EmitRegSave(Mask);
Logan Chien2bcc42c2013-01-30 15:39:04 +00001292}
1293
Saleem Abdulrasoold9f08602014-01-21 02:33:10 +00001294void ARMELFStreamer::emitUnwindRaw(int64_t Offset,
1295 const SmallVectorImpl<uint8_t> &Opcodes) {
1296 FlushPendingOffset();
1297 SPOffset = SPOffset - Offset;
1298 UnwindOpAsm.EmitRaw(Opcodes);
1299}
1300
Tim Northover5cc3dc82012-12-07 16:50:23 +00001301namespace llvm {
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001302
Rafael Espindola73870dd2015-03-16 21:43:42 +00001303MCTargetStreamer *createARMTargetAsmStreamer(MCStreamer &S,
1304 formatted_raw_ostream &OS,
1305 MCInstPrinter *InstPrint,
1306 bool isVerboseAsm) {
1307 return new ARMTargetAsmStreamer(S, OS, *InstPrint, isVerboseAsm);
Rafael Espindolaa17151a2013-10-08 13:08:17 +00001308}
1309
Peter Collingbourne20c72592015-02-19 00:45:02 +00001310MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S) {
1311 return new ARMTargetStreamer(S);
1312}
1313
Rafael Espindolacd584a82015-03-19 01:50:16 +00001314MCTargetStreamer *createARMObjectTargetStreamer(MCStreamer &S,
1315 const MCSubtargetInfo &STI) {
1316 Triple TT(STI.getTargetTriple());
1317 if (TT.getObjectFormat() == Triple::ELF)
1318 return new ARMTargetELFStreamer(S);
1319 return new ARMTargetStreamer(S);
1320}
1321
Rafael Espindola7b61ddf2014-10-15 16:12:52 +00001322MCELFStreamer *createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
Rafael Espindola5560a4c2015-04-14 22:14:34 +00001323 raw_pwrite_stream &OS,
1324 MCCodeEmitter *Emitter, bool RelaxAll,
1325 bool IsThumb) {
Rafael Espindola24ea09e2014-01-26 06:06:37 +00001326 ARMELFStreamer *S = new ARMELFStreamer(Context, TAB, OS, Emitter, IsThumb);
Rafael Espindolaac4ad252013-10-05 16:42:21 +00001327 // FIXME: This should eventually end up somewhere else where more
1328 // intelligent flag decisions can be made. For now we are just maintaining
1329 // the status quo for ARM and setting EF_ARM_EABI_VER5 as the default.
1330 S->getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
1331
Tim Northover5cc3dc82012-12-07 16:50:23 +00001332 if (RelaxAll)
1333 S->getAssembler().setRelaxAll(true);
Tim Northover5cc3dc82012-12-07 16:50:23 +00001334 return S;
1335 }
1336
1337}
1338
1339