1 //===-------- MipsELFStreamer.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 #include "MipsELFStreamer.h"
11 #include "MipsOptionRecord.h"
12 #include "MipsTargetStreamer.h"
13 #include "llvm/BinaryFormat/ELF.h"
14 #include "llvm/MC/MCAsmBackend.h"
15 #include "llvm/MC/MCAssembler.h"
16 #include "llvm/MC/MCCodeEmitter.h"
17 #include "llvm/MC/MCContext.h"
18 #include "llvm/MC/MCDwarf.h"
19 #include "llvm/MC/MCInst.h"
20 #include "llvm/MC/MCObjectWriter.h"
21 #include "llvm/MC/MCSymbolELF.h"
22 #include "llvm/Support/Casting.h"
23 
24 using namespace llvm;
25 
26 MipsELFStreamer::MipsELFStreamer(MCContext &Context,
27                                  std::unique_ptr<MCAsmBackend> MAB,
28                                  std::unique_ptr<MCObjectWriter> OW,
29                                  std::unique_ptr<MCCodeEmitter> Emitter)
30     : MCELFStreamer(Context, std::move(MAB), std::move(OW),
31                     std::move(Emitter)) {
32   RegInfoRecord = new MipsRegInfoRecord(this, Context);
33   MipsOptionRecords.push_back(
34       std::unique_ptr<MipsRegInfoRecord>(RegInfoRecord));
35 }
36 
37 void MipsELFStreamer::EmitInstruction(const MCInst &Inst,
38                                       const MCSubtargetInfo &STI, bool) {
39   MCELFStreamer::EmitInstruction(Inst, STI);
40 
41   MCContext &Context = getContext();
42   const MCRegisterInfo *MCRegInfo = Context.getRegisterInfo();
43 
44   for (unsigned OpIndex = 0; OpIndex < Inst.getNumOperands(); ++OpIndex) {
45     const MCOperand &Op = Inst.getOperand(OpIndex);
46 
47     if (!Op.isReg())
48       continue;
49 
50     unsigned Reg = Op.getReg();
51     RegInfoRecord->SetPhysRegUsed(Reg, MCRegInfo);
52   }
53 
54   createPendingLabelRelocs();
55 }
56 
57 void MipsELFStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
58   Frame.Begin = getContext().createTempSymbol();
59   MCELFStreamer::EmitLabel(Frame.Begin);
60 }
61 
62 MCSymbol *MipsELFStreamer::EmitCFILabel() {
63   MCSymbol *Label = getContext().createTempSymbol("cfi", true);
64   MCELFStreamer::EmitLabel(Label);
65   return Label;
66 }
67 
68 void MipsELFStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
69   Frame.End = getContext().createTempSymbol();
70   MCELFStreamer::EmitLabel(Frame.End);
71 }
72 
73 void MipsELFStreamer::createPendingLabelRelocs() {
74   MipsTargetELFStreamer *ELFTargetStreamer =
75       static_cast<MipsTargetELFStreamer *>(getTargetStreamer());
76 
77   // FIXME: Also mark labels when in MIPS16 mode.
78   if (ELFTargetStreamer->isMicroMipsEnabled()) {
79     for (auto *L : Labels) {
80       auto *Label = cast<MCSymbolELF>(L);
81       getAssembler().registerSymbol(*Label);
82       Label->setOther(ELF::STO_MIPS_MICROMIPS);
83     }
84   }
85 
86   Labels.clear();
87 }
88 
89 void MipsELFStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
90   MCELFStreamer::EmitLabel(Symbol);
91   Labels.push_back(Symbol);
92 }
93 
94 void MipsELFStreamer::SwitchSection(MCSection *Section,
95                                     const MCExpr *Subsection) {
96   MCELFStreamer::SwitchSection(Section, Subsection);
97   Labels.clear();
98 }
99 
100 void MipsELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
101                                     SMLoc Loc) {
102   MCELFStreamer::EmitValueImpl(Value, Size, Loc);
103   Labels.clear();
104 }
105 
106 void MipsELFStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
107   MCELFStreamer::EmitIntValue(Value, Size);
108   Labels.clear();
109 }
110 
111 void MipsELFStreamer::EmitMipsOptionRecords() {
112   for (const auto &I : MipsOptionRecords)
113     I->EmitMipsOptionRecord();
114 }
115 
116 MCELFStreamer *llvm::createMipsELFStreamer(
117     MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
118     std::unique_ptr<MCObjectWriter> OW, std::unique_ptr<MCCodeEmitter> Emitter,
119     bool RelaxAll) {
120   return new MipsELFStreamer(Context, std::move(MAB), std::move(OW),
121                              std::move(Emitter));
122 }
123