1 //===-- RISCVMCExpr.cpp - RISC-V specific MC expression classes -----------===//
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 file contains the implementation of the assembly expression modifiers
10 // accepted by the RISC-V architecture (e.g. ":lo12:", ":gottprel_g1:", ...).
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "RISCVMCExpr.h"
15 #include "MCTargetDesc/RISCVAsmBackend.h"
16 #include "RISCVFixupKinds.h"
17 #include "llvm/BinaryFormat/ELF.h"
18 #include "llvm/MC/MCAsmLayout.h"
19 #include "llvm/MC/MCAssembler.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCStreamer.h"
22 #include "llvm/MC/MCSymbolELF.h"
23 #include "llvm/MC/MCValue.h"
24 #include "llvm/Support/Casting.h"
25 #include "llvm/Support/ErrorHandling.h"
26 
27 using namespace llvm;
28 
29 #define DEBUG_TYPE "riscvmcexpr"
30 
31 const RISCVMCExpr *RISCVMCExpr::create(const MCExpr *Expr, VariantKind Kind,
32                                        MCContext &Ctx) {
33   return new (Ctx) RISCVMCExpr(Expr, Kind);
34 }
35 
36 void RISCVMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
37   VariantKind Kind = getKind();
38   bool HasVariant = ((Kind != VK_RISCV_None) && (Kind != VK_RISCV_CALL) &&
39                      (Kind != VK_RISCV_CALL_PLT));
40 
41   if (HasVariant)
42     OS << '%' << getVariantKindName(getKind()) << '(';
43   Expr->print(OS, MAI);
44   if (Kind == VK_RISCV_CALL_PLT)
45     OS << "@plt";
46   if (HasVariant)
47     OS << ')';
48 }
49 
50 const MCFixup *RISCVMCExpr::getPCRelHiFixup(const MCFragment **DFOut) const {
51   MCValue AUIPCLoc;
52   if (!getSubExpr()->evaluateAsRelocatable(AUIPCLoc, nullptr, nullptr))
53     return nullptr;
54 
55   const MCSymbolRefExpr *AUIPCSRE = AUIPCLoc.getSymA();
56   if (!AUIPCSRE)
57     return nullptr;
58 
59   const MCSymbol *AUIPCSymbol = &AUIPCSRE->getSymbol();
60   const auto *DF = dyn_cast_or_null<MCDataFragment>(AUIPCSymbol->getFragment());
61 
62   if (!DF)
63     return nullptr;
64 
65   uint64_t Offset = AUIPCSymbol->getOffset();
66   if (DF->getContents().size() == Offset) {
67     DF = dyn_cast_or_null<MCDataFragment>(DF->getNextNode());
68     if (!DF)
69       return nullptr;
70     Offset = 0;
71   }
72 
73   for (const MCFixup &F : DF->getFixups()) {
74     if (F.getOffset() != Offset)
75       continue;
76 
77     switch ((unsigned)F.getKind()) {
78     default:
79       continue;
80     case RISCV::fixup_riscv_got_hi20:
81     case RISCV::fixup_riscv_tls_got_hi20:
82     case RISCV::fixup_riscv_tls_gd_hi20:
83     case RISCV::fixup_riscv_pcrel_hi20:
84       if (DFOut)
85         *DFOut = DF;
86       return &F;
87     }
88   }
89 
90   return nullptr;
91 }
92 
93 bool RISCVMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
94                                             const MCAsmLayout *Layout,
95                                             const MCFixup *Fixup) const {
96   // Explicitly drop the layout and assembler to prevent any symbolic folding in
97   // the expression handling.  This is required to preserve symbolic difference
98   // expressions to emit the paired relocations.
99   if (!getSubExpr()->evaluateAsRelocatable(Res, nullptr, nullptr))
100     return false;
101 
102   Res =
103       MCValue::get(Res.getSymA(), Res.getSymB(), Res.getConstant(), getKind());
104   // Custom fixup types are not valid with symbol difference expressions.
105   return Res.getSymB() ? getKind() == VK_RISCV_None : true;
106 }
107 
108 void RISCVMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
109   Streamer.visitUsedExpr(*getSubExpr());
110 }
111 
112 RISCVMCExpr::VariantKind RISCVMCExpr::getVariantKindForName(StringRef name) {
113   return StringSwitch<RISCVMCExpr::VariantKind>(name)
114       .Case("lo", VK_RISCV_LO)
115       .Case("hi", VK_RISCV_HI)
116       .Case("pcrel_lo", VK_RISCV_PCREL_LO)
117       .Case("pcrel_hi", VK_RISCV_PCREL_HI)
118       .Case("got_pcrel_hi", VK_RISCV_GOT_HI)
119       .Case("tprel_lo", VK_RISCV_TPREL_LO)
120       .Case("tprel_hi", VK_RISCV_TPREL_HI)
121       .Case("tprel_add", VK_RISCV_TPREL_ADD)
122       .Case("tls_ie_pcrel_hi", VK_RISCV_TLS_GOT_HI)
123       .Case("tls_gd_pcrel_hi", VK_RISCV_TLS_GD_HI)
124       .Default(VK_RISCV_Invalid);
125 }
126 
127 StringRef RISCVMCExpr::getVariantKindName(VariantKind Kind) {
128   switch (Kind) {
129   case VK_RISCV_Invalid:
130   case VK_RISCV_None:
131     llvm_unreachable("Invalid ELF symbol kind");
132   case VK_RISCV_LO:
133     return "lo";
134   case VK_RISCV_HI:
135     return "hi";
136   case VK_RISCV_PCREL_LO:
137     return "pcrel_lo";
138   case VK_RISCV_PCREL_HI:
139     return "pcrel_hi";
140   case VK_RISCV_GOT_HI:
141     return "got_pcrel_hi";
142   case VK_RISCV_TPREL_LO:
143     return "tprel_lo";
144   case VK_RISCV_TPREL_HI:
145     return "tprel_hi";
146   case VK_RISCV_TPREL_ADD:
147     return "tprel_add";
148   case VK_RISCV_TLS_GOT_HI:
149     return "tls_ie_pcrel_hi";
150   case VK_RISCV_TLS_GD_HI:
151     return "tls_gd_pcrel_hi";
152   case VK_RISCV_CALL:
153     return "call";
154   case VK_RISCV_CALL_PLT:
155     return "call_plt";
156   case VK_RISCV_32_PCREL:
157     return "32_pcrel";
158   }
159   llvm_unreachable("Invalid ELF symbol kind");
160 }
161 
162 static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
163   switch (Expr->getKind()) {
164   case MCExpr::Target:
165     llvm_unreachable("Can't handle nested target expression");
166     break;
167   case MCExpr::Constant:
168     break;
169 
170   case MCExpr::Binary: {
171     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
172     fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
173     fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
174     break;
175   }
176 
177   case MCExpr::SymbolRef: {
178     // We're known to be under a TLS fixup, so any symbol should be
179     // modified. There should be only one.
180     const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
181     cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
182     break;
183   }
184 
185   case MCExpr::Unary:
186     fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
187     break;
188   }
189 }
190 
191 void RISCVMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
192   switch (getKind()) {
193   default:
194     return;
195   case VK_RISCV_TPREL_HI:
196   case VK_RISCV_TLS_GOT_HI:
197   case VK_RISCV_TLS_GD_HI:
198     break;
199   }
200 
201   fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
202 }
203 
204 bool RISCVMCExpr::evaluateAsConstant(int64_t &Res) const {
205   MCValue Value;
206 
207   if (Kind == VK_RISCV_PCREL_HI || Kind == VK_RISCV_PCREL_LO ||
208       Kind == VK_RISCV_GOT_HI || Kind == VK_RISCV_TPREL_HI ||
209       Kind == VK_RISCV_TPREL_LO || Kind == VK_RISCV_TPREL_ADD ||
210       Kind == VK_RISCV_TLS_GOT_HI || Kind == VK_RISCV_TLS_GD_HI ||
211       Kind == VK_RISCV_CALL || Kind == VK_RISCV_CALL_PLT)
212     return false;
213 
214   if (!getSubExpr()->evaluateAsRelocatable(Value, nullptr, nullptr))
215     return false;
216 
217   if (!Value.isAbsolute())
218     return false;
219 
220   Res = evaluateAsInt64(Value.getConstant());
221   return true;
222 }
223 
224 int64_t RISCVMCExpr::evaluateAsInt64(int64_t Value) const {
225   switch (Kind) {
226   default:
227     llvm_unreachable("Invalid kind");
228   case VK_RISCV_LO:
229     return SignExtend64<12>(Value);
230   case VK_RISCV_HI:
231     // Add 1 if bit 11 is 1, to compensate for low 12 bits being negative.
232     return ((Value + 0x800) >> 12) & 0xfffff;
233   }
234 }
235