RISCVMCExpr.cpp revision 360784 
1//===-- RISCVMCExpr.cpp - RISCV 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 RISCV architecture (e.g. ":lo12:", ":gottprel_g1:", ...).
11//
12//===----------------------------------------------------------------------===//
13
14#include "RISCVMCExpr.h"
15#include "MCTargetDesc/RISCVAsmBackend.h"
16#include "RISCV.h"
17#include "RISCVFixupKinds.h"
18#include "llvm/BinaryFormat/ELF.h"
19#include "llvm/MC/MCAsmLayout.h"
20#include "llvm/MC/MCAssembler.h"
21#include "llvm/MC/MCContext.h"
22#include "llvm/MC/MCStreamer.h"
23#include "llvm/MC/MCSymbolELF.h"
24#include "llvm/MC/MCValue.h"
25#include "llvm/Support/ErrorHandling.h"
26
27using namespace llvm;
28
29#define DEBUG_TYPE "riscvmcexpr"
30
31const RISCVMCExpr *RISCVMCExpr::create(const MCExpr *Expr, VariantKind Kind,
32                                       MCContext &Ctx) {
33  return new (Ctx) RISCVMCExpr(Expr, Kind);
34}
35
36void 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
50const 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
93bool RISCVMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
94                                            const MCAsmLayout *Layout,
95                                            const MCFixup *Fixup) const {
96  if (!getSubExpr()->evaluateAsRelocatable(Res, Layout, Fixup))
97    return false;
98
99  // Some custom fixup types are not valid with symbol difference expressions
100  if (Res.getSymA() && Res.getSymB()) {
101    switch (getKind()) {
102    default:
103      return true;
104    case VK_RISCV_LO:
105    case VK_RISCV_HI:
106    case VK_RISCV_PCREL_LO:
107    case VK_RISCV_PCREL_HI:
108    case VK_RISCV_GOT_HI:
109    case VK_RISCV_TPREL_LO:
110    case VK_RISCV_TPREL_HI:
111    case VK_RISCV_TPREL_ADD:
112    case VK_RISCV_TLS_GOT_HI:
113    case VK_RISCV_TLS_GD_HI:
114      return false;
115    }
116  }
117
118  return true;
119}
120
121void RISCVMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
122  Streamer.visitUsedExpr(*getSubExpr());
123}
124
125RISCVMCExpr::VariantKind RISCVMCExpr::getVariantKindForName(StringRef name) {
126  return StringSwitch<RISCVMCExpr::VariantKind>(name)
127      .Case("lo", VK_RISCV_LO)
128      .Case("hi", VK_RISCV_HI)
129      .Case("pcrel_lo", VK_RISCV_PCREL_LO)
130      .Case("pcrel_hi", VK_RISCV_PCREL_HI)
131      .Case("got_pcrel_hi", VK_RISCV_GOT_HI)
132      .Case("tprel_lo", VK_RISCV_TPREL_LO)
133      .Case("tprel_hi", VK_RISCV_TPREL_HI)
134      .Case("tprel_add", VK_RISCV_TPREL_ADD)
135      .Case("tls_ie_pcrel_hi", VK_RISCV_TLS_GOT_HI)
136      .Case("tls_gd_pcrel_hi", VK_RISCV_TLS_GD_HI)
137      .Default(VK_RISCV_Invalid);
138}
139
140StringRef RISCVMCExpr::getVariantKindName(VariantKind Kind) {
141  switch (Kind) {
142  default:
143    llvm_unreachable("Invalid ELF symbol kind");
144  case VK_RISCV_LO:
145    return "lo";
146  case VK_RISCV_HI:
147    return "hi";
148  case VK_RISCV_PCREL_LO:
149    return "pcrel_lo";
150  case VK_RISCV_PCREL_HI:
151    return "pcrel_hi";
152  case VK_RISCV_GOT_HI:
153    return "got_pcrel_hi";
154  case VK_RISCV_TPREL_LO:
155    return "tprel_lo";
156  case VK_RISCV_TPREL_HI:
157    return "tprel_hi";
158  case VK_RISCV_TPREL_ADD:
159    return "tprel_add";
160  case VK_RISCV_TLS_GOT_HI:
161    return "tls_ie_pcrel_hi";
162  case VK_RISCV_TLS_GD_HI:
163    return "tls_gd_pcrel_hi";
164  }
165}
166
167static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
168  switch (Expr->getKind()) {
169  case MCExpr::Target:
170    llvm_unreachable("Can't handle nested target expression");
171    break;
172  case MCExpr::Constant:
173    break;
174
175  case MCExpr::Binary: {
176    const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
177    fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
178    fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
179    break;
180  }
181
182  case MCExpr::SymbolRef: {
183    // We're known to be under a TLS fixup, so any symbol should be
184    // modified. There should be only one.
185    const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
186    cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
187    break;
188  }
189
190  case MCExpr::Unary:
191    fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
192    break;
193  }
194}
195
196void RISCVMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
197  switch (getKind()) {
198  default:
199    return;
200  case VK_RISCV_TPREL_HI:
201  case VK_RISCV_TLS_GOT_HI:
202  case VK_RISCV_TLS_GD_HI:
203    break;
204  }
205
206  fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
207}
208
209bool RISCVMCExpr::evaluateAsConstant(int64_t &Res) const {
210  MCValue Value;
211
212  if (Kind == VK_RISCV_PCREL_HI || Kind == VK_RISCV_PCREL_LO ||
213      Kind == VK_RISCV_GOT_HI || Kind == VK_RISCV_TPREL_HI ||
214      Kind == VK_RISCV_TPREL_LO || Kind == VK_RISCV_TPREL_ADD ||
215      Kind == VK_RISCV_TLS_GOT_HI || Kind == VK_RISCV_TLS_GD_HI ||
216      Kind == VK_RISCV_CALL || Kind == VK_RISCV_CALL_PLT)
217    return false;
218
219  if (!getSubExpr()->evaluateAsRelocatable(Value, nullptr, nullptr))
220    return false;
221
222  if (!Value.isAbsolute())
223    return false;
224
225  Res = evaluateAsInt64(Value.getConstant());
226  return true;
227}
228
229int64_t RISCVMCExpr::evaluateAsInt64(int64_t Value) const {
230  switch (Kind) {
231  default:
232    llvm_unreachable("Invalid kind");
233  case VK_RISCV_LO:
234    return SignExtend64<12>(Value);
235  case VK_RISCV_HI:
236    // Add 1 if bit 11 is 1, to compensate for low 12 bits being negative.
237    return ((Value + 0x800) >> 12) & 0xfffff;
238  }
239}
240