1 //===-- VEMCExpr.cpp - VE 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 VE architecture (e.g. "%hi", "%lo", ...). 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "VEMCExpr.h" 15 #include "llvm/BinaryFormat/ELF.h" 16 #include "llvm/MC/MCAssembler.h" 17 #include "llvm/MC/MCContext.h" 18 #include "llvm/MC/MCObjectStreamer.h" 19 #include "llvm/MC/MCSymbolELF.h" 20 #include "llvm/MC/MCValue.h" 21 #include "llvm/Support/Casting.h" 22 23 using namespace llvm; 24 25 #define DEBUG_TYPE "vemcexpr" 26 27 const VEMCExpr *VEMCExpr::create(VariantKind Kind, const MCExpr *Expr, 28 MCContext &Ctx) { 29 return new (Ctx) VEMCExpr(Kind, Expr); 30 } 31 32 void VEMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const { 33 34 bool closeParen = printVariantKind(OS, Kind); 35 36 const MCExpr *Expr = getSubExpr(); 37 Expr->print(OS, MAI); 38 39 if (closeParen) 40 OS << ')'; 41 printVariantKindSuffix(OS, Kind); 42 } 43 44 bool VEMCExpr::printVariantKind(raw_ostream &OS, VariantKind Kind) { 45 switch (Kind) { 46 case VK_VE_None: 47 case VK_VE_REFLONG: 48 return false; 49 50 case VK_VE_HI32: 51 case VK_VE_LO32: 52 case VK_VE_PC_HI32: 53 case VK_VE_PC_LO32: 54 case VK_VE_GOT_HI32: 55 case VK_VE_GOT_LO32: 56 case VK_VE_GOTOFF_HI32: 57 case VK_VE_GOTOFF_LO32: 58 case VK_VE_PLT_HI32: 59 case VK_VE_PLT_LO32: 60 case VK_VE_TLS_GD_HI32: 61 case VK_VE_TLS_GD_LO32: 62 case VK_VE_TPOFF_HI32: 63 case VK_VE_TPOFF_LO32: 64 // Use suffix for these variant kinds 65 return false; 66 } 67 return true; 68 } 69 70 void VEMCExpr::printVariantKindSuffix(raw_ostream &OS, VariantKind Kind) { 71 switch (Kind) { 72 case VK_VE_None: 73 case VK_VE_REFLONG: 74 break; 75 case VK_VE_HI32: 76 OS << "@hi"; 77 break; 78 case VK_VE_LO32: 79 OS << "@lo"; 80 break; 81 case VK_VE_PC_HI32: 82 OS << "@pc_hi"; 83 break; 84 case VK_VE_PC_LO32: 85 OS << "@pc_lo"; 86 break; 87 case VK_VE_GOT_HI32: 88 OS << "@got_hi"; 89 break; 90 case VK_VE_GOT_LO32: 91 OS << "@got_lo"; 92 break; 93 case VK_VE_GOTOFF_HI32: 94 OS << "@gotoff_hi"; 95 break; 96 case VK_VE_GOTOFF_LO32: 97 OS << "@gotoff_lo"; 98 break; 99 case VK_VE_PLT_HI32: 100 OS << "@plt_hi"; 101 break; 102 case VK_VE_PLT_LO32: 103 OS << "@plt_lo"; 104 break; 105 case VK_VE_TLS_GD_HI32: 106 OS << "@tls_gd_hi"; 107 break; 108 case VK_VE_TLS_GD_LO32: 109 OS << "@tls_gd_lo"; 110 break; 111 case VK_VE_TPOFF_HI32: 112 OS << "@tpoff_hi"; 113 break; 114 case VK_VE_TPOFF_LO32: 115 OS << "@tpoff_lo"; 116 break; 117 } 118 } 119 120 VEMCExpr::VariantKind VEMCExpr::parseVariantKind(StringRef name) { 121 return StringSwitch<VEMCExpr::VariantKind>(name) 122 .Case("hi", VK_VE_HI32) 123 .Case("lo", VK_VE_LO32) 124 .Case("pc_hi", VK_VE_PC_HI32) 125 .Case("pc_lo", VK_VE_PC_LO32) 126 .Case("got_hi", VK_VE_GOT_HI32) 127 .Case("got_lo", VK_VE_GOT_LO32) 128 .Case("gotoff_hi", VK_VE_GOTOFF_HI32) 129 .Case("gotoff_lo", VK_VE_GOTOFF_LO32) 130 .Case("plt_hi", VK_VE_PLT_HI32) 131 .Case("plt_lo", VK_VE_PLT_LO32) 132 .Case("tls_gd_hi", VK_VE_TLS_GD_HI32) 133 .Case("tls_gd_lo", VK_VE_TLS_GD_LO32) 134 .Case("tpoff_hi", VK_VE_TPOFF_HI32) 135 .Case("tpoff_lo", VK_VE_TPOFF_LO32) 136 .Default(VK_VE_None); 137 } 138 139 VE::Fixups VEMCExpr::getFixupKind(VEMCExpr::VariantKind Kind) { 140 switch (Kind) { 141 default: 142 llvm_unreachable("Unhandled VEMCExpr::VariantKind"); 143 case VK_VE_REFLONG: 144 return VE::fixup_ve_reflong; 145 case VK_VE_HI32: 146 return VE::fixup_ve_hi32; 147 case VK_VE_LO32: 148 return VE::fixup_ve_lo32; 149 case VK_VE_PC_HI32: 150 return VE::fixup_ve_pc_hi32; 151 case VK_VE_PC_LO32: 152 return VE::fixup_ve_pc_lo32; 153 case VK_VE_GOT_HI32: 154 return VE::fixup_ve_got_hi32; 155 case VK_VE_GOT_LO32: 156 return VE::fixup_ve_got_lo32; 157 case VK_VE_GOTOFF_HI32: 158 return VE::fixup_ve_gotoff_hi32; 159 case VK_VE_GOTOFF_LO32: 160 return VE::fixup_ve_gotoff_lo32; 161 case VK_VE_PLT_HI32: 162 return VE::fixup_ve_plt_hi32; 163 case VK_VE_PLT_LO32: 164 return VE::fixup_ve_plt_lo32; 165 case VK_VE_TLS_GD_HI32: 166 return VE::fixup_ve_tls_gd_hi32; 167 case VK_VE_TLS_GD_LO32: 168 return VE::fixup_ve_tls_gd_lo32; 169 case VK_VE_TPOFF_HI32: 170 return VE::fixup_ve_tpoff_hi32; 171 case VK_VE_TPOFF_LO32: 172 return VE::fixup_ve_tpoff_lo32; 173 } 174 } 175 176 bool VEMCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, 177 const MCFixup *Fixup) const { 178 if (!getSubExpr()->evaluateAsRelocatable(Res, Asm, Fixup)) 179 return false; 180 181 Res = 182 MCValue::get(Res.getSymA(), Res.getSymB(), Res.getConstant(), getKind()); 183 184 return true; 185 } 186 187 static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) { 188 switch (Expr->getKind()) { 189 case MCExpr::Target: 190 llvm_unreachable("Can't handle nested target expr!"); 191 break; 192 193 case MCExpr::Constant: 194 break; 195 196 case MCExpr::Binary: { 197 const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr); 198 fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm); 199 fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm); 200 break; 201 } 202 203 case MCExpr::SymbolRef: { 204 // We're known to be under a TLS fixup, so any symbol should be 205 // modified. There should be only one. 206 const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr); 207 cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS); 208 break; 209 } 210 211 case MCExpr::Unary: 212 fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm); 213 break; 214 } 215 } 216 217 void VEMCExpr::visitUsedExpr(MCStreamer &Streamer) const { 218 Streamer.visitUsedExpr(*getSubExpr()); 219 } 220 221 void VEMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const { 222 switch (getKind()) { 223 default: 224 return; 225 case VK_VE_TLS_GD_HI32: 226 case VK_VE_TLS_GD_LO32: 227 case VK_VE_TPOFF_HI32: 228 case VK_VE_TPOFF_LO32: 229 break; 230 } 231 fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm); 232 } 233