1 //===-------- PPCELFStreamer.cpp - ELF Object Output ---------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This is a custom MCELFStreamer for PowerPC.
10 //
11 // The purpose of the custom ELF streamer is to allow us to intercept
12 // instructions as they are being emitted and align all 8 byte instructions
13 // to a 64 byte boundary if required (by adding a 4 byte nop). This is important
14 // because 8 byte instructions are not allowed to cross 64 byte boundaries
15 // and by aliging anything that is within 4 bytes of the boundary we can
16 // guarantee that the 8 byte instructions do not cross that boundary.
17 //
18 //===----------------------------------------------------------------------===//
19 
20 
21 #include "PPCELFStreamer.h"
22 #include "PPCFixupKinds.h"
23 #include "PPCInstrInfo.h"
24 #include "PPCMCCodeEmitter.h"
25 #include "llvm/BinaryFormat/ELF.h"
26 #include "llvm/MC/MCAsmBackend.h"
27 #include "llvm/MC/MCAssembler.h"
28 #include "llvm/MC/MCCodeEmitter.h"
29 #include "llvm/MC/MCContext.h"
30 #include "llvm/MC/MCInst.h"
31 #include "llvm/MC/MCInstrDesc.h"
32 #include "llvm/MC/MCObjectWriter.h"
33 #include "llvm/MC/MCSymbolELF.h"
34 #include "llvm/Support/Casting.h"
35 #include "llvm/Support/SourceMgr.h"
36 
37 using namespace llvm;
38 
PPCELFStreamer(MCContext & Context,std::unique_ptr<MCAsmBackend> MAB,std::unique_ptr<MCObjectWriter> OW,std::unique_ptr<MCCodeEmitter> Emitter)39 PPCELFStreamer::PPCELFStreamer(MCContext &Context,
40                                std::unique_ptr<MCAsmBackend> MAB,
41                                std::unique_ptr<MCObjectWriter> OW,
42                                std::unique_ptr<MCCodeEmitter> Emitter)
43     : MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(Emitter)),
44       LastLabel(nullptr) {}
45 
emitPrefixedInstruction(const MCInst & Inst,const MCSubtargetInfo & STI)46 void PPCELFStreamer::emitPrefixedInstruction(const MCInst &Inst,
47                                              const MCSubtargetInfo &STI) {
48   // Prefixed instructions must not cross a 64-byte boundary (i.e. prefix is
49   // before the boundary and the remaining 4-bytes are after the boundary). In
50   // order to achieve this, a nop is added prior to any such boundary-crossing
51   // prefixed instruction. Align to 64 bytes if possible but add a maximum of 4
52   // bytes when trying to do that. If alignment requires adding more than 4
53   // bytes then the instruction won't be aligned. When emitting a code alignment
54   // a new fragment is created for this alignment. This fragment will contain
55   // all of the nops required as part of the alignment operation. In the cases
56   // when no nops are added then The fragment is still created but it remains
57   // empty.
58   emitCodeAlignment(Align(64), &STI, 4);
59 
60   // Emit the instruction.
61   // Since the previous emit created a new fragment then adding this instruction
62   // also forces the addition of a new fragment. Inst is now the first
63   // instruction in that new fragment.
64   MCELFStreamer::emitInstruction(Inst, STI);
65 
66   // The above instruction is forced to start a new fragment because it
67   // comes after a code alignment fragment. Get that new fragment.
68   MCFragment *InstructionFragment = getCurrentFragment();
69   SMLoc InstLoc = Inst.getLoc();
70   // Check if there was a last label emitted.
71   if (LastLabel && !LastLabel->isUnset() && LastLabelLoc.isValid() &&
72       InstLoc.isValid()) {
73     const SourceMgr *SourceManager = getContext().getSourceManager();
74     unsigned InstLine = SourceManager->FindLineNumber(InstLoc);
75     unsigned LabelLine = SourceManager->FindLineNumber(LastLabelLoc);
76     // If the Label and the Instruction are on the same line then move the
77     // label to the top of the fragment containing the aligned instruction that
78     // was just added.
79     if (InstLine == LabelLine) {
80       assignFragment(LastLabel, InstructionFragment);
81       LastLabel->setOffset(0);
82     }
83   }
84 }
85 
emitInstruction(const MCInst & Inst,const MCSubtargetInfo & STI)86 void PPCELFStreamer::emitInstruction(const MCInst &Inst,
87                                      const MCSubtargetInfo &STI) {
88   PPCMCCodeEmitter *Emitter =
89       static_cast<PPCMCCodeEmitter*>(getAssembler().getEmitterPtr());
90 
91   // If the instruction is a part of the GOT to PC-Rel link time optimization
92   // instruction pair, return a value, otherwise return std::nullopt. A true
93   // returned value means the instruction is the PLDpc and a false value means
94   // it is the user instruction.
95   std::optional<bool> IsPartOfGOTToPCRelPair =
96       isPartOfGOTToPCRelPair(Inst, STI);
97 
98   // User of the GOT-indirect address.
99   // For example, the load that will get the relocation as follows:
100   // .reloc .Lpcrel1-8,R_PPC64_PCREL_OPT,.-(.Lpcrel1-8)
101   //  lwa 3, 4(3)
102   if (IsPartOfGOTToPCRelPair && !*IsPartOfGOTToPCRelPair)
103     emitGOTToPCRelReloc(Inst);
104 
105   // Special handling is only for prefixed instructions.
106   if (!Emitter->isPrefixedInstruction(Inst)) {
107     MCELFStreamer::emitInstruction(Inst, STI);
108     return;
109   }
110   emitPrefixedInstruction(Inst, STI);
111 
112   // Producer of the GOT-indirect address.
113   // For example, the prefixed load from the got that will get the label as
114   // follows:
115   //  pld 3, vec@got@pcrel(0), 1
116   // .Lpcrel1:
117   if (IsPartOfGOTToPCRelPair && *IsPartOfGOTToPCRelPair)
118     emitGOTToPCRelLabel(Inst);
119 }
120 
emitLabel(MCSymbol * Symbol,SMLoc Loc)121 void PPCELFStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
122   LastLabel = Symbol;
123   LastLabelLoc = Loc;
124   MCELFStreamer::emitLabel(Symbol);
125 }
126 
127 // This linker time GOT PC Relative optimization relocation will look like this:
128 //   pld <reg> symbol@got@pcrel
129 // <Label###>:
130 //   .reloc Label###-8,R_PPC64_PCREL_OPT,.-(Label###-8)
131 //   load <loadedreg>, 0(<reg>)
132 // The reason we place the label after the PLDpc instruction is that there
133 // may be an alignment nop before it since prefixed instructions must not
134 // cross a 64-byte boundary (please see
135 // PPCELFStreamer::emitPrefixedInstruction()). When referring to the
136 // label, we subtract the width of a prefixed instruction (8 bytes) to ensure
137 // we refer to the PLDpc.
emitGOTToPCRelReloc(const MCInst & Inst)138 void PPCELFStreamer::emitGOTToPCRelReloc(const MCInst &Inst) {
139   // Get the last operand which contains the symbol.
140   const MCOperand &Operand = Inst.getOperand(Inst.getNumOperands() - 1);
141   assert(Operand.isExpr() && "Expecting an MCExpr.");
142   // Cast the last operand to MCSymbolRefExpr to get the symbol.
143   const MCExpr *Expr = Operand.getExpr();
144   const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr);
145   assert(SymExpr->getKind() == MCSymbolRefExpr::VK_PPC_PCREL_OPT &&
146          "Expecting a symbol of type VK_PPC_PCREL_OPT");
147   MCSymbol *LabelSym =
148       getContext().getOrCreateSymbol(SymExpr->getSymbol().getName());
149   const MCExpr *LabelExpr = MCSymbolRefExpr::create(LabelSym, getContext());
150   const MCExpr *Eight = MCConstantExpr::create(8, getContext());
151   // SubExpr is just Label###-8
152   const MCExpr *SubExpr =
153       MCBinaryExpr::createSub(LabelExpr, Eight, getContext());
154   MCSymbol *CurrentLocation = getContext().createTempSymbol();
155   const MCExpr *CurrentLocationExpr =
156       MCSymbolRefExpr::create(CurrentLocation, getContext());
157   // SubExpr2 is .-(Label###-8)
158   const MCExpr *SubExpr2 =
159       MCBinaryExpr::createSub(CurrentLocationExpr, SubExpr, getContext());
160 
161   MCDataFragment *DF = static_cast<MCDataFragment *>(LabelSym->getFragment());
162   assert(DF && "Expecting a valid data fragment.");
163   MCFixupKind FixupKind = static_cast<MCFixupKind>(FirstLiteralRelocationKind +
164                                                    ELF::R_PPC64_PCREL_OPT);
165   DF->getFixups().push_back(
166       MCFixup::create(LabelSym->getOffset() - 8, SubExpr2,
167                       FixupKind, Inst.getLoc()));
168   emitLabel(CurrentLocation, Inst.getLoc());
169 }
170 
171 // Emit the label that immediately follows the PLDpc for a link time GOT PC Rel
172 // optimization.
emitGOTToPCRelLabel(const MCInst & Inst)173 void PPCELFStreamer::emitGOTToPCRelLabel(const MCInst &Inst) {
174   // Get the last operand which contains the symbol.
175   const MCOperand &Operand = Inst.getOperand(Inst.getNumOperands() - 1);
176   assert(Operand.isExpr() && "Expecting an MCExpr.");
177   // Cast the last operand to MCSymbolRefExpr to get the symbol.
178   const MCExpr *Expr = Operand.getExpr();
179   const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr);
180   assert(SymExpr->getKind() == MCSymbolRefExpr::VK_PPC_PCREL_OPT &&
181          "Expecting a symbol of type VK_PPC_PCREL_OPT");
182   MCSymbol *LabelSym =
183       getContext().getOrCreateSymbol(SymExpr->getSymbol().getName());
184   emitLabel(LabelSym, Inst.getLoc());
185 }
186 
187 // This funciton checks if the parameter Inst is part of the setup for a link
188 // time GOT PC Relative optimization. For example in this situation:
189 // <MCInst PLDpc <MCOperand Reg:282> <MCOperand Expr:(glob_double@got@pcrel)>
190 //   <MCOperand Imm:0> <MCOperand Expr:(.Lpcrel@<<invalid>>)>>
191 // <MCInst SOME_LOAD <MCOperand Reg:22> <MCOperand Imm:0> <MCOperand Reg:282>
192 //   <MCOperand Expr:(.Lpcrel@<<invalid>>)>>
193 // The above is a pair of such instructions and this function will not return
194 // std::nullopt for either one of them. In both cases we are looking for the
195 // last operand <MCOperand Expr:(.Lpcrel@<<invalid>>)> which needs to be an
196 // MCExpr and has the flag MCSymbolRefExpr::VK_PPC_PCREL_OPT. After that we just
197 // look at the opcode and in the case of PLDpc we will return true. For the load
198 // (or store) this function will return false indicating it has found the second
199 // instruciton in the pair.
isPartOfGOTToPCRelPair(const MCInst & Inst,const MCSubtargetInfo & STI)200 std::optional<bool> llvm::isPartOfGOTToPCRelPair(const MCInst &Inst,
201                                                  const MCSubtargetInfo &STI) {
202   // Need at least two operands.
203   if (Inst.getNumOperands() < 2)
204     return std::nullopt;
205 
206   unsigned LastOp = Inst.getNumOperands() - 1;
207   // The last operand needs to be an MCExpr and it needs to have a variant kind
208   // of VK_PPC_PCREL_OPT. If it does not satisfy these conditions it is not a
209   // link time GOT PC Rel opt instruction and we can ignore it and return
210   // std::nullopt.
211   const MCOperand &Operand = Inst.getOperand(LastOp);
212   if (!Operand.isExpr())
213     return std::nullopt;
214 
215   // Check for the variant kind VK_PPC_PCREL_OPT in this expression.
216   const MCExpr *Expr = Operand.getExpr();
217   const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr);
218   if (!SymExpr || SymExpr->getKind() != MCSymbolRefExpr::VK_PPC_PCREL_OPT)
219     return std::nullopt;
220 
221   return (Inst.getOpcode() == PPC::PLDpc);
222 }
223 
createPPCELFStreamer(MCContext & Context,std::unique_ptr<MCAsmBackend> MAB,std::unique_ptr<MCObjectWriter> OW,std::unique_ptr<MCCodeEmitter> Emitter)224 MCELFStreamer *llvm::createPPCELFStreamer(
225     MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
226     std::unique_ptr<MCObjectWriter> OW,
227     std::unique_ptr<MCCodeEmitter> Emitter) {
228   return new PPCELFStreamer(Context, std::move(MAB), std::move(OW),
229                             std::move(Emitter));
230 }
231