Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 1 | //===- MCExpr.cpp - Assembly Level Expression Implementation --------------===// |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 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 | |
Chandler Carruth | 6bda14b | 2017-06-06 11:49:48 +0000 | [diff] [blame] | 10 | #include "llvm/MC/MCExpr.h" |
Daniel Dunbar | 5376c2a | 2010-03-23 23:47:14 +0000 | [diff] [blame] | 11 | #include "llvm/ADT/Statistic.h" |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 12 | #include "llvm/ADT/StringSwitch.h" |
David Peixotto | 8ad70b3 | 2013-12-04 22:43:20 +0000 | [diff] [blame] | 13 | #include "llvm/MC/MCAsmInfo.h" |
Daniel Dunbar | 5c5228a | 2010-03-11 05:53:37 +0000 | [diff] [blame] | 14 | #include "llvm/MC/MCAsmLayout.h" |
| 15 | #include "llvm/MC/MCAssembler.h" |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 16 | #include "llvm/MC/MCContext.h" |
Craig Topper | 6e80c28 | 2012-03-26 06:58:25 +0000 | [diff] [blame] | 17 | #include "llvm/MC/MCObjectWriter.h" |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 18 | #include "llvm/MC/MCSymbol.h" |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 19 | #include "llvm/MC/MCValue.h" |
Eugene Zelenko | 1d43552 | 2017-02-07 23:02:00 +0000 | [diff] [blame] | 20 | #include "llvm/Support/Casting.h" |
| 21 | #include "llvm/Support/Compiler.h" |
David Greene | a8cbfb8 | 2010-01-05 01:28:07 +0000 | [diff] [blame] | 22 | #include "llvm/Support/Debug.h" |
Chandler Carruth | f3e8502 | 2012-01-10 18:08:01 +0000 | [diff] [blame] | 23 | #include "llvm/Support/ErrorHandling.h" |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 24 | #include "llvm/Support/raw_ostream.h" |
Eugene Zelenko | 1d43552 | 2017-02-07 23:02:00 +0000 | [diff] [blame] | 25 | #include <cassert> |
| 26 | #include <cstdint> |
| 27 | |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 28 | using namespace llvm; |
| 29 | |
Chandler Carruth | f58e376 | 2014-04-22 03:04:17 +0000 | [diff] [blame] | 30 | #define DEBUG_TYPE "mcexpr" |
| 31 | |
Daniel Dunbar | 5376c2a | 2010-03-23 23:47:14 +0000 | [diff] [blame] | 32 | namespace { |
| 33 | namespace stats { |
Eugene Zelenko | 1d43552 | 2017-02-07 23:02:00 +0000 | [diff] [blame] | 34 | |
Daniel Dunbar | 5376c2a | 2010-03-23 23:47:14 +0000 | [diff] [blame] | 35 | STATISTIC(MCExprEvaluate, "Number of MCExpr evaluations"); |
Eugene Zelenko | 1d43552 | 2017-02-07 23:02:00 +0000 | [diff] [blame] | 36 | |
| 37 | } // end namespace stats |
| 38 | } // end anonymous namespace |
Daniel Dunbar | 5376c2a | 2010-03-23 23:47:14 +0000 | [diff] [blame] | 39 | |
Daniel Sanders | fe98b2f | 2016-05-03 13:35:44 +0000 | [diff] [blame] | 40 | void MCExpr::print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens) const { |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 41 | switch (getKind()) { |
Chris Lattner | 38d022e | 2010-02-08 19:41:07 +0000 | [diff] [blame] | 42 | case MCExpr::Target: |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 43 | return cast<MCTargetExpr>(this)->printImpl(OS, MAI); |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 44 | case MCExpr::Constant: |
| 45 | OS << cast<MCConstantExpr>(*this).getValue(); |
| 46 | return; |
| 47 | |
Chris Lattner | 22833a3 | 2009-09-08 23:20:50 +0000 | [diff] [blame] | 48 | case MCExpr::SymbolRef: { |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 49 | const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*this); |
| 50 | const MCSymbol &Sym = SRE.getSymbol(); |
Chris Lattner | edb9d84 | 2010-11-15 02:46:57 +0000 | [diff] [blame] | 51 | // Parenthesize names that start with $ so that they don't look like |
| 52 | // absolute names. |
Daniel Sanders | fe98b2f | 2016-05-03 13:35:44 +0000 | [diff] [blame] | 53 | bool UseParens = |
Eugene Zelenko | 1d43552 | 2017-02-07 23:02:00 +0000 | [diff] [blame] | 54 | !InParens && !Sym.getName().empty() && Sym.getName()[0] == '$'; |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 55 | if (UseParens) { |
| 56 | OS << '('; |
| 57 | Sym.print(OS, MAI); |
| 58 | OS << ')'; |
| 59 | } else |
| 60 | Sym.print(OS, MAI); |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 61 | |
Benjamin Kramer | dd13643 | 2014-10-11 17:57:27 +0000 | [diff] [blame] | 62 | if (SRE.getKind() != MCSymbolRefExpr::VK_None) |
| 63 | SRE.printVariantKind(OS); |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 64 | |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 65 | return; |
Chris Lattner | 22833a3 | 2009-09-08 23:20:50 +0000 | [diff] [blame] | 66 | } |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 67 | |
| 68 | case MCExpr::Unary: { |
| 69 | const MCUnaryExpr &UE = cast<MCUnaryExpr>(*this); |
| 70 | switch (UE.getOpcode()) { |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 71 | case MCUnaryExpr::LNot: OS << '!'; break; |
| 72 | case MCUnaryExpr::Minus: OS << '-'; break; |
| 73 | case MCUnaryExpr::Not: OS << '~'; break; |
| 74 | case MCUnaryExpr::Plus: OS << '+'; break; |
| 75 | } |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 76 | UE.getSubExpr()->print(OS, MAI); |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 77 | return; |
| 78 | } |
| 79 | |
| 80 | case MCExpr::Binary: { |
| 81 | const MCBinaryExpr &BE = cast<MCBinaryExpr>(*this); |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 82 | |
Chris Lattner | 3cfc551 | 2009-09-08 06:34:07 +0000 | [diff] [blame] | 83 | // Only print parens around the LHS if it is non-trivial. |
| 84 | if (isa<MCConstantExpr>(BE.getLHS()) || isa<MCSymbolRefExpr>(BE.getLHS())) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 85 | BE.getLHS()->print(OS, MAI); |
Chris Lattner | 3cfc551 | 2009-09-08 06:34:07 +0000 | [diff] [blame] | 86 | } else { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 87 | OS << '('; |
| 88 | BE.getLHS()->print(OS, MAI); |
| 89 | OS << ')'; |
Chris Lattner | 3cfc551 | 2009-09-08 06:34:07 +0000 | [diff] [blame] | 90 | } |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 91 | |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 92 | switch (BE.getOpcode()) { |
Chris Lattner | 7975b8f | 2009-09-08 06:37:35 +0000 | [diff] [blame] | 93 | case MCBinaryExpr::Add: |
| 94 | // Print "X-42" instead of "X+-42". |
| 95 | if (const MCConstantExpr *RHSC = dyn_cast<MCConstantExpr>(BE.getRHS())) { |
| 96 | if (RHSC->getValue() < 0) { |
| 97 | OS << RHSC->getValue(); |
| 98 | return; |
| 99 | } |
| 100 | } |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 101 | |
Chris Lattner | 7975b8f | 2009-09-08 06:37:35 +0000 | [diff] [blame] | 102 | OS << '+'; |
| 103 | break; |
Ahmed Bougacha | 177c148 | 2015-04-28 00:21:32 +0000 | [diff] [blame] | 104 | case MCBinaryExpr::AShr: OS << ">>"; break; |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 105 | case MCBinaryExpr::And: OS << '&'; break; |
| 106 | case MCBinaryExpr::Div: OS << '/'; break; |
| 107 | case MCBinaryExpr::EQ: OS << "=="; break; |
| 108 | case MCBinaryExpr::GT: OS << '>'; break; |
| 109 | case MCBinaryExpr::GTE: OS << ">="; break; |
| 110 | case MCBinaryExpr::LAnd: OS << "&&"; break; |
| 111 | case MCBinaryExpr::LOr: OS << "||"; break; |
Ahmed Bougacha | 177c148 | 2015-04-28 00:21:32 +0000 | [diff] [blame] | 112 | case MCBinaryExpr::LShr: OS << ">>"; break; |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 113 | case MCBinaryExpr::LT: OS << '<'; break; |
| 114 | case MCBinaryExpr::LTE: OS << "<="; break; |
| 115 | case MCBinaryExpr::Mod: OS << '%'; break; |
| 116 | case MCBinaryExpr::Mul: OS << '*'; break; |
| 117 | case MCBinaryExpr::NE: OS << "!="; break; |
| 118 | case MCBinaryExpr::Or: OS << '|'; break; |
| 119 | case MCBinaryExpr::Shl: OS << "<<"; break; |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 120 | case MCBinaryExpr::Sub: OS << '-'; break; |
| 121 | case MCBinaryExpr::Xor: OS << '^'; break; |
| 122 | } |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 123 | |
Chris Lattner | 3cfc551 | 2009-09-08 06:34:07 +0000 | [diff] [blame] | 124 | // Only print parens around the LHS if it is non-trivial. |
| 125 | if (isa<MCConstantExpr>(BE.getRHS()) || isa<MCSymbolRefExpr>(BE.getRHS())) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 126 | BE.getRHS()->print(OS, MAI); |
Chris Lattner | 3cfc551 | 2009-09-08 06:34:07 +0000 | [diff] [blame] | 127 | } else { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 128 | OS << '('; |
| 129 | BE.getRHS()->print(OS, MAI); |
| 130 | OS << ')'; |
Chris Lattner | 3cfc551 | 2009-09-08 06:34:07 +0000 | [diff] [blame] | 131 | } |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 132 | return; |
| 133 | } |
| 134 | } |
| 135 | |
Craig Topper | a2886c2 | 2012-02-07 05:05:23 +0000 | [diff] [blame] | 136 | llvm_unreachable("Invalid expression kind!"); |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 137 | } |
| 138 | |
Aaron Ballman | 615eb47 | 2017-10-15 14:32:27 +0000 | [diff] [blame] | 139 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
Yaron Keren | eb2a254 | 2016-01-29 20:50:44 +0000 | [diff] [blame] | 140 | LLVM_DUMP_METHOD void MCExpr::dump() const { |
Rafael Espindola | f4a1365 | 2015-05-27 13:05:42 +0000 | [diff] [blame] | 141 | dbgs() << *this; |
David Greene | a8cbfb8 | 2010-01-05 01:28:07 +0000 | [diff] [blame] | 142 | dbgs() << '\n'; |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 143 | } |
Matthias Braun | 8c209aa | 2017-01-28 02:02:38 +0000 | [diff] [blame] | 144 | #endif |
Daniel Dunbar | b34a2b9 | 2009-08-31 08:07:33 +0000 | [diff] [blame] | 145 | |
| 146 | /* *** */ |
| 147 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 148 | const MCBinaryExpr *MCBinaryExpr::create(Opcode Opc, const MCExpr *LHS, |
Chad Rosier | 9245e12 | 2017-01-19 20:06:32 +0000 | [diff] [blame] | 149 | const MCExpr *RHS, MCContext &Ctx, |
| 150 | SMLoc Loc) { |
| 151 | return new (Ctx) MCBinaryExpr(Opc, LHS, RHS, Loc); |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 152 | } |
| 153 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 154 | const MCUnaryExpr *MCUnaryExpr::create(Opcode Opc, const MCExpr *Expr, |
Sanne Wouda | 9dfa6ad | 2017-03-10 13:08:20 +0000 | [diff] [blame] | 155 | MCContext &Ctx, SMLoc Loc) { |
| 156 | return new (Ctx) MCUnaryExpr(Opc, Expr, Loc); |
Daniel Dunbar | f363645 | 2009-08-31 08:07:22 +0000 | [diff] [blame] | 157 | } |
| 158 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 159 | const MCConstantExpr *MCConstantExpr::create(int64_t Value, MCContext &Ctx) { |
Daniel Dunbar | f363645 | 2009-08-31 08:07:22 +0000 | [diff] [blame] | 160 | return new (Ctx) MCConstantExpr(Value); |
| 161 | } |
| 162 | |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 163 | /* *** */ |
| 164 | |
Benjamin Kramer | dd13643 | 2014-10-11 17:57:27 +0000 | [diff] [blame] | 165 | MCSymbolRefExpr::MCSymbolRefExpr(const MCSymbol *Symbol, VariantKind Kind, |
Chad Rosier | 9245e12 | 2017-01-19 20:06:32 +0000 | [diff] [blame] | 166 | const MCAsmInfo *MAI, SMLoc Loc) |
| 167 | : MCExpr(MCExpr::SymbolRef, Loc), Kind(Kind), |
Benjamin Kramer | dd13643 | 2014-10-11 17:57:27 +0000 | [diff] [blame] | 168 | UseParensForSymbolVariant(MAI->useParensForSymbolVariant()), |
| 169 | HasSubsectionsViaSymbols(MAI->hasSubsectionsViaSymbols()), |
| 170 | Symbol(Symbol) { |
| 171 | assert(Symbol); |
| 172 | } |
| 173 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 174 | const MCSymbolRefExpr *MCSymbolRefExpr::create(const MCSymbol *Sym, |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 175 | VariantKind Kind, |
Chad Rosier | 9245e12 | 2017-01-19 20:06:32 +0000 | [diff] [blame] | 176 | MCContext &Ctx, SMLoc Loc) { |
| 177 | return new (Ctx) MCSymbolRefExpr(Sym, Kind, Ctx.getAsmInfo(), Loc); |
Daniel Dunbar | f363645 | 2009-08-31 08:07:22 +0000 | [diff] [blame] | 178 | } |
| 179 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 180 | const MCSymbolRefExpr *MCSymbolRefExpr::create(StringRef Name, VariantKind Kind, |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 181 | MCContext &Ctx) { |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 182 | return create(Ctx.getOrCreateSymbol(Name), Kind, Ctx); |
Chris Lattner | 6a833f6 | 2009-09-16 01:26:31 +0000 | [diff] [blame] | 183 | } |
| 184 | |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 185 | StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) { |
| 186 | switch (Kind) { |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 187 | case VK_Invalid: return "<<invalid>>"; |
| 188 | case VK_None: return "<<none>>"; |
| 189 | |
Colin LeMahieu | 0e05192 | 2016-02-10 18:32:01 +0000 | [diff] [blame] | 190 | case VK_DTPOFF: return "DTPOFF"; |
| 191 | case VK_DTPREL: return "DTPREL"; |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 192 | case VK_GOT: return "GOT"; |
| 193 | case VK_GOTOFF: return "GOTOFF"; |
Colin LeMahieu | ea21142 | 2016-02-09 19:17:34 +0000 | [diff] [blame] | 194 | case VK_GOTREL: return "GOTREL"; |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 195 | case VK_GOTPCREL: return "GOTPCREL"; |
| 196 | case VK_GOTTPOFF: return "GOTTPOFF"; |
| 197 | case VK_INDNTPOFF: return "INDNTPOFF"; |
| 198 | case VK_NTPOFF: return "NTPOFF"; |
Rafael Espindola | b3b49bb | 2010-10-28 14:22:44 +0000 | [diff] [blame] | 199 | case VK_GOTNTPOFF: return "GOTNTPOFF"; |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 200 | case VK_PLT: return "PLT"; |
| 201 | case VK_TLSGD: return "TLSGD"; |
Rafael Espindola | 2dbec3f | 2010-10-28 15:02:40 +0000 | [diff] [blame] | 202 | case VK_TLSLD: return "TLSLD"; |
Rafael Espindola | 6f23eb3 | 2010-10-28 14:37:09 +0000 | [diff] [blame] | 203 | case VK_TLSLDM: return "TLSLDM"; |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 204 | case VK_TPOFF: return "TPOFF"; |
Colin LeMahieu | 0e05192 | 2016-02-10 18:32:01 +0000 | [diff] [blame] | 205 | case VK_TPREL: return "TPREL"; |
Davide Italiano | 249c45d | 2016-03-15 00:25:22 +0000 | [diff] [blame] | 206 | case VK_TLSCALL: return "tlscall"; |
Davide Italiano | dfdf278 | 2016-03-15 17:29:52 +0000 | [diff] [blame] | 207 | case VK_TLSDESC: return "tlsdesc"; |
Chris Lattner | 94f0c14 | 2010-11-14 22:22:59 +0000 | [diff] [blame] | 208 | case VK_TLVP: return "TLVP"; |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 209 | case VK_TLVPPAGE: return "TLVPPAGE"; |
| 210 | case VK_TLVPPAGEOFF: return "TLVPPAGEOFF"; |
| 211 | case VK_PAGE: return "PAGE"; |
| 212 | case VK_PAGEOFF: return "PAGEOFF"; |
| 213 | case VK_GOTPAGE: return "GOTPAGE"; |
| 214 | case VK_GOTPAGEOFF: return "GOTPAGEOFF"; |
Benjamin Kramer | 9c9e0a2 | 2013-03-30 16:21:50 +0000 | [diff] [blame] | 215 | case VK_SECREL: return "SECREL32"; |
Davide Italiano | fcae934 | 2015-03-04 06:49:39 +0000 | [diff] [blame] | 216 | case VK_SIZE: return "SIZE"; |
Rafael Espindola | 7fadc0e | 2014-03-20 02:12:01 +0000 | [diff] [blame] | 217 | case VK_WEAKREF: return "WEAKREF"; |
Peter Collingbourne | d763c4c | 2017-01-31 18:28:44 +0000 | [diff] [blame] | 218 | case VK_X86_ABS8: return "ABS8"; |
David Peixotto | 8ad70b3 | 2013-12-04 22:43:20 +0000 | [diff] [blame] | 219 | case VK_ARM_NONE: return "none"; |
Peter Collingbourne | 97aae40 | 2015-10-26 18:23:16 +0000 | [diff] [blame] | 220 | case VK_ARM_GOT_PREL: return "GOT_PREL"; |
David Peixotto | 8ad70b3 | 2013-12-04 22:43:20 +0000 | [diff] [blame] | 221 | case VK_ARM_TARGET1: return "target1"; |
| 222 | case VK_ARM_TARGET2: return "target2"; |
| 223 | case VK_ARM_PREL31: return "prel31"; |
Saleem Abdulrasool | fe78197 | 2015-01-11 04:39:18 +0000 | [diff] [blame] | 224 | case VK_ARM_SBREL: return "sbrel"; |
Kai Nacke | e51c813 | 2014-01-20 11:00:40 +0000 | [diff] [blame] | 225 | case VK_ARM_TLSLDO: return "tlsldo"; |
Saleem Abdulrasool | 56e06e8 | 2014-01-30 04:02:47 +0000 | [diff] [blame] | 226 | case VK_ARM_TLSDESCSEQ: return "tlsdescseq"; |
Dylan McKay | ba23343 | 2017-12-09 08:01:28 +0000 | [diff] [blame] | 227 | case VK_AVR_NONE: return "none"; |
| 228 | case VK_AVR_LO8: return "lo8"; |
| 229 | case VK_AVR_HI8: return "hi8"; |
| 230 | case VK_AVR_HLO8: return "hlo8"; |
| 231 | case VK_AVR_DIFF8: return "diff8"; |
| 232 | case VK_AVR_DIFF16: return "diff16"; |
| 233 | case VK_AVR_DIFF32: return "diff32"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 234 | case VK_PPC_LO: return "l"; |
Ulrich Weigand | e67c565 | 2013-06-21 14:42:49 +0000 | [diff] [blame] | 235 | case VK_PPC_HI: return "h"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 236 | case VK_PPC_HA: return "ha"; |
Ulrich Weigand | e9126f5 | 2013-06-21 14:43:42 +0000 | [diff] [blame] | 237 | case VK_PPC_HIGHER: return "higher"; |
| 238 | case VK_PPC_HIGHERA: return "highera"; |
| 239 | case VK_PPC_HIGHEST: return "highest"; |
| 240 | case VK_PPC_HIGHESTA: return "highesta"; |
Ulrich Weigand | 93372b4 | 2013-06-25 16:49:50 +0000 | [diff] [blame] | 241 | case VK_PPC_GOT_LO: return "got@l"; |
| 242 | case VK_PPC_GOT_HI: return "got@h"; |
| 243 | case VK_PPC_GOT_HA: return "got@ha"; |
Ulrich Weigand | 68e2e1b | 2013-06-20 22:39:42 +0000 | [diff] [blame] | 244 | case VK_PPC_TOCBASE: return "tocbase"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 245 | case VK_PPC_TOC: return "toc"; |
| 246 | case VK_PPC_TOC_LO: return "toc@l"; |
Ulrich Weigand | 72ddbd6 | 2013-06-21 14:43:10 +0000 | [diff] [blame] | 247 | case VK_PPC_TOC_HI: return "toc@h"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 248 | case VK_PPC_TOC_HA: return "toc@ha"; |
Ulrich Weigand | f11efe7 | 2013-07-01 23:33:29 +0000 | [diff] [blame] | 249 | case VK_PPC_DTPMOD: return "dtpmod"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 250 | case VK_PPC_TPREL_LO: return "tprel@l"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 251 | case VK_PPC_TPREL_HI: return "tprel@h"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 252 | case VK_PPC_TPREL_HA: return "tprel@ha"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 253 | case VK_PPC_TPREL_HIGHER: return "tprel@higher"; |
| 254 | case VK_PPC_TPREL_HIGHERA: return "tprel@highera"; |
| 255 | case VK_PPC_TPREL_HIGHEST: return "tprel@highest"; |
| 256 | case VK_PPC_TPREL_HIGHESTA: return "tprel@highesta"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 257 | case VK_PPC_DTPREL_LO: return "dtprel@l"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 258 | case VK_PPC_DTPREL_HI: return "dtprel@h"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 259 | case VK_PPC_DTPREL_HA: return "dtprel@ha"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 260 | case VK_PPC_DTPREL_HIGHER: return "dtprel@higher"; |
| 261 | case VK_PPC_DTPREL_HIGHERA: return "dtprel@highera"; |
| 262 | case VK_PPC_DTPREL_HIGHEST: return "dtprel@highest"; |
| 263 | case VK_PPC_DTPREL_HIGHESTA: return "dtprel@highesta"; |
| 264 | case VK_PPC_GOT_TPREL: return "got@tprel"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 265 | case VK_PPC_GOT_TPREL_LO: return "got@tprel@l"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 266 | case VK_PPC_GOT_TPREL_HI: return "got@tprel@h"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 267 | case VK_PPC_GOT_TPREL_HA: return "got@tprel@ha"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 268 | case VK_PPC_GOT_DTPREL: return "got@dtprel"; |
| 269 | case VK_PPC_GOT_DTPREL_LO: return "got@dtprel@l"; |
| 270 | case VK_PPC_GOT_DTPREL_HI: return "got@dtprel@h"; |
| 271 | case VK_PPC_GOT_DTPREL_HA: return "got@dtprel@ha"; |
Bill Schmidt | ca4a0c9 | 2012-12-04 16:18:08 +0000 | [diff] [blame] | 272 | case VK_PPC_TLS: return "tls"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 273 | case VK_PPC_GOT_TLSGD: return "got@tlsgd"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 274 | case VK_PPC_GOT_TLSGD_LO: return "got@tlsgd@l"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 275 | case VK_PPC_GOT_TLSGD_HI: return "got@tlsgd@h"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 276 | case VK_PPC_GOT_TLSGD_HA: return "got@tlsgd@ha"; |
Ulrich Weigand | 52cf8e4 | 2013-07-09 16:41:09 +0000 | [diff] [blame] | 277 | case VK_PPC_TLSGD: return "tlsgd"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 278 | case VK_PPC_GOT_TLSLD: return "got@tlsld"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 279 | case VK_PPC_GOT_TLSLD_LO: return "got@tlsld@l"; |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 280 | case VK_PPC_GOT_TLSLD_HI: return "got@tlsld@h"; |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 281 | case VK_PPC_GOT_TLSLD_HA: return "got@tlsld@ha"; |
Ulrich Weigand | 52cf8e4 | 2013-07-09 16:41:09 +0000 | [diff] [blame] | 282 | case VK_PPC_TLSLD: return "tlsld"; |
Justin Hibbits | a88b605 | 2014-11-12 15:16:30 +0000 | [diff] [blame] | 283 | case VK_PPC_LOCAL: return "local"; |
Reid Kleckner | 81782f0 | 2014-09-25 02:09:18 +0000 | [diff] [blame] | 284 | case VK_COFF_IMGREL32: return "IMGREL"; |
Colin LeMahieu | b662565 | 2015-05-01 21:14:21 +0000 | [diff] [blame] | 285 | case VK_Hexagon_PCREL: return "PCREL"; |
| 286 | case VK_Hexagon_LO16: return "LO16"; |
| 287 | case VK_Hexagon_HI16: return "HI16"; |
| 288 | case VK_Hexagon_GPREL: return "GPREL"; |
| 289 | case VK_Hexagon_GD_GOT: return "GDGOT"; |
| 290 | case VK_Hexagon_LD_GOT: return "LDGOT"; |
| 291 | case VK_Hexagon_GD_PLT: return "GDPLT"; |
| 292 | case VK_Hexagon_LD_PLT: return "LDPLT"; |
| 293 | case VK_Hexagon_IE: return "IE"; |
| 294 | case VK_Hexagon_IE_GOT: return "IEGOT"; |
Dan Gohman | 26c6765 | 2016-01-11 23:38:05 +0000 | [diff] [blame] | 295 | case VK_WebAssembly_FUNCTION: return "FUNCTION"; |
Dan Gohman | d934cb8 | 2017-02-24 23:18:00 +0000 | [diff] [blame] | 296 | case VK_WebAssembly_TYPEINDEX: return "TYPEINDEX"; |
Konstantin Zhuravlyov | 2a2ac37 | 2016-10-14 04:21:32 +0000 | [diff] [blame] | 297 | case VK_AMDGPU_GOTPCREL32_LO: return "gotpcrel32@lo"; |
| 298 | case VK_AMDGPU_GOTPCREL32_HI: return "gotpcrel32@hi"; |
| 299 | case VK_AMDGPU_REL32_LO: return "rel32@lo"; |
| 300 | case VK_AMDGPU_REL32_HI: return "rel32@hi"; |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 301 | } |
Chandler Carruth | f3e8502 | 2012-01-10 18:08:01 +0000 | [diff] [blame] | 302 | llvm_unreachable("Invalid variant kind"); |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | MCSymbolRefExpr::VariantKind |
| 306 | MCSymbolRefExpr::getVariantKindForName(StringRef Name) { |
Roman Divacky | a93d002 | 2014-12-18 23:12:34 +0000 | [diff] [blame] | 307 | return StringSwitch<VariantKind>(Name.lower()) |
Colin LeMahieu | 0e05192 | 2016-02-10 18:32:01 +0000 | [diff] [blame] | 308 | .Case("dtprel", VK_DTPREL) |
| 309 | .Case("dtpoff", VK_DTPOFF) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 310 | .Case("got", VK_GOT) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 311 | .Case("gotoff", VK_GOTOFF) |
Colin LeMahieu | ea21142 | 2016-02-09 19:17:34 +0000 | [diff] [blame] | 312 | .Case("gotrel", VK_GOTREL) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 313 | .Case("gotpcrel", VK_GOTPCREL) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 314 | .Case("gottpoff", VK_GOTTPOFF) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 315 | .Case("indntpoff", VK_INDNTPOFF) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 316 | .Case("ntpoff", VK_NTPOFF) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 317 | .Case("gotntpoff", VK_GOTNTPOFF) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 318 | .Case("plt", VK_PLT) |
Davide Italiano | 249c45d | 2016-03-15 00:25:22 +0000 | [diff] [blame] | 319 | .Case("tlscall", VK_TLSCALL) |
Davide Italiano | dfdf278 | 2016-03-15 17:29:52 +0000 | [diff] [blame] | 320 | .Case("tlsdesc", VK_TLSDESC) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 321 | .Case("tlsgd", VK_TLSGD) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 322 | .Case("tlsld", VK_TLSLD) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 323 | .Case("tlsldm", VK_TLSLDM) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 324 | .Case("tpoff", VK_TPOFF) |
Colin LeMahieu | 0e05192 | 2016-02-10 18:32:01 +0000 | [diff] [blame] | 325 | .Case("tprel", VK_TPREL) |
Rafael Espindola | 8bac423 | 2011-01-23 16:11:25 +0000 | [diff] [blame] | 326 | .Case("tlvp", VK_TLVP) |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 327 | .Case("tlvppage", VK_TLVPPAGE) |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 328 | .Case("tlvppageoff", VK_TLVPPAGEOFF) |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 329 | .Case("page", VK_PAGE) |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 330 | .Case("pageoff", VK_PAGEOFF) |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 331 | .Case("gotpage", VK_GOTPAGE) |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 332 | .Case("gotpageoff", VK_GOTPAGEOFF) |
Nico Rieck | 1da4529 | 2013-04-10 23:28:17 +0000 | [diff] [blame] | 333 | .Case("imgrel", VK_COFF_IMGREL32) |
Rafael Espindola | b770f89 | 2013-04-25 19:27:05 +0000 | [diff] [blame] | 334 | .Case("secrel32", VK_SECREL) |
Davide Italiano | fcae934 | 2015-03-04 06:49:39 +0000 | [diff] [blame] | 335 | .Case("size", VK_SIZE) |
Peter Collingbourne | d763c4c | 2017-01-31 18:28:44 +0000 | [diff] [blame] | 336 | .Case("abs8", VK_X86_ABS8) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 337 | .Case("l", VK_PPC_LO) |
Ulrich Weigand | e67c565 | 2013-06-21 14:42:49 +0000 | [diff] [blame] | 338 | .Case("h", VK_PPC_HI) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 339 | .Case("ha", VK_PPC_HA) |
Ulrich Weigand | e9126f5 | 2013-06-21 14:43:42 +0000 | [diff] [blame] | 340 | .Case("higher", VK_PPC_HIGHER) |
Ulrich Weigand | e9126f5 | 2013-06-21 14:43:42 +0000 | [diff] [blame] | 341 | .Case("highera", VK_PPC_HIGHERA) |
Ulrich Weigand | e9126f5 | 2013-06-21 14:43:42 +0000 | [diff] [blame] | 342 | .Case("highest", VK_PPC_HIGHEST) |
Ulrich Weigand | e9126f5 | 2013-06-21 14:43:42 +0000 | [diff] [blame] | 343 | .Case("highesta", VK_PPC_HIGHESTA) |
Ulrich Weigand | 93372b4 | 2013-06-25 16:49:50 +0000 | [diff] [blame] | 344 | .Case("got@l", VK_PPC_GOT_LO) |
Ulrich Weigand | 93372b4 | 2013-06-25 16:49:50 +0000 | [diff] [blame] | 345 | .Case("got@h", VK_PPC_GOT_HI) |
Ulrich Weigand | 93372b4 | 2013-06-25 16:49:50 +0000 | [diff] [blame] | 346 | .Case("got@ha", VK_PPC_GOT_HA) |
Justin Hibbits | 0c0d5de | 2014-12-17 06:23:35 +0000 | [diff] [blame] | 347 | .Case("local", VK_PPC_LOCAL) |
Ulrich Weigand | 68e2e1b | 2013-06-20 22:39:42 +0000 | [diff] [blame] | 348 | .Case("tocbase", VK_PPC_TOCBASE) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 349 | .Case("toc", VK_PPC_TOC) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 350 | .Case("toc@l", VK_PPC_TOC_LO) |
Ulrich Weigand | 72ddbd6 | 2013-06-21 14:43:10 +0000 | [diff] [blame] | 351 | .Case("toc@h", VK_PPC_TOC_HI) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 352 | .Case("toc@ha", VK_PPC_TOC_HA) |
Ulrich Weigand | 2c3a219 | 2013-05-03 19:52:35 +0000 | [diff] [blame] | 353 | .Case("tls", VK_PPC_TLS) |
Ulrich Weigand | f11efe7 | 2013-07-01 23:33:29 +0000 | [diff] [blame] | 354 | .Case("dtpmod", VK_PPC_DTPMOD) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 355 | .Case("tprel@l", VK_PPC_TPREL_LO) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 356 | .Case("tprel@h", VK_PPC_TPREL_HI) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 357 | .Case("tprel@ha", VK_PPC_TPREL_HA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 358 | .Case("tprel@higher", VK_PPC_TPREL_HIGHER) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 359 | .Case("tprel@highera", VK_PPC_TPREL_HIGHERA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 360 | .Case("tprel@highest", VK_PPC_TPREL_HIGHEST) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 361 | .Case("tprel@highesta", VK_PPC_TPREL_HIGHESTA) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 362 | .Case("dtprel@l", VK_PPC_DTPREL_LO) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 363 | .Case("dtprel@h", VK_PPC_DTPREL_HI) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 364 | .Case("dtprel@ha", VK_PPC_DTPREL_HA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 365 | .Case("dtprel@higher", VK_PPC_DTPREL_HIGHER) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 366 | .Case("dtprel@highera", VK_PPC_DTPREL_HIGHERA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 367 | .Case("dtprel@highest", VK_PPC_DTPREL_HIGHEST) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 368 | .Case("dtprel@highesta", VK_PPC_DTPREL_HIGHESTA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 369 | .Case("got@tprel", VK_PPC_GOT_TPREL) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 370 | .Case("got@tprel@l", VK_PPC_GOT_TPREL_LO) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 371 | .Case("got@tprel@h", VK_PPC_GOT_TPREL_HI) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 372 | .Case("got@tprel@ha", VK_PPC_GOT_TPREL_HA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 373 | .Case("got@dtprel", VK_PPC_GOT_DTPREL) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 374 | .Case("got@dtprel@l", VK_PPC_GOT_DTPREL_LO) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 375 | .Case("got@dtprel@h", VK_PPC_GOT_DTPREL_HI) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 376 | .Case("got@dtprel@ha", VK_PPC_GOT_DTPREL_HA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 377 | .Case("got@tlsgd", VK_PPC_GOT_TLSGD) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 378 | .Case("got@tlsgd@l", VK_PPC_GOT_TLSGD_LO) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 379 | .Case("got@tlsgd@h", VK_PPC_GOT_TLSGD_HI) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 380 | .Case("got@tlsgd@ha", VK_PPC_GOT_TLSGD_HA) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 381 | .Case("got@tlsld", VK_PPC_GOT_TLSLD) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 382 | .Case("got@tlsld@l", VK_PPC_GOT_TLSLD_LO) |
Ulrich Weigand | 876a0d0 | 2013-06-21 14:44:15 +0000 | [diff] [blame] | 383 | .Case("got@tlsld@h", VK_PPC_GOT_TLSLD_HI) |
Ulrich Weigand | d51c09f | 2013-06-21 14:42:20 +0000 | [diff] [blame] | 384 | .Case("got@tlsld@ha", VK_PPC_GOT_TLSLD_HA) |
Krzysztof Parzyszek | a45c0e0 | 2015-12-18 18:47:27 +0000 | [diff] [blame] | 385 | .Case("gdgot", VK_Hexagon_GD_GOT) |
| 386 | .Case("gdplt", VK_Hexagon_GD_PLT) |
| 387 | .Case("iegot", VK_Hexagon_IE_GOT) |
| 388 | .Case("ie", VK_Hexagon_IE) |
| 389 | .Case("ldgot", VK_Hexagon_LD_GOT) |
| 390 | .Case("ldplt", VK_Hexagon_LD_PLT) |
| 391 | .Case("pcrel", VK_Hexagon_PCREL) |
David Peixotto | 8ad70b3 | 2013-12-04 22:43:20 +0000 | [diff] [blame] | 392 | .Case("none", VK_ARM_NONE) |
Peter Collingbourne | 97aae40 | 2015-10-26 18:23:16 +0000 | [diff] [blame] | 393 | .Case("got_prel", VK_ARM_GOT_PREL) |
David Peixotto | 8ad70b3 | 2013-12-04 22:43:20 +0000 | [diff] [blame] | 394 | .Case("target1", VK_ARM_TARGET1) |
David Peixotto | 8ad70b3 | 2013-12-04 22:43:20 +0000 | [diff] [blame] | 395 | .Case("target2", VK_ARM_TARGET2) |
David Peixotto | 8ad70b3 | 2013-12-04 22:43:20 +0000 | [diff] [blame] | 396 | .Case("prel31", VK_ARM_PREL31) |
Saleem Abdulrasool | fe78197 | 2015-01-11 04:39:18 +0000 | [diff] [blame] | 397 | .Case("sbrel", VK_ARM_SBREL) |
Kai Nacke | e51c813 | 2014-01-20 11:00:40 +0000 | [diff] [blame] | 398 | .Case("tlsldo", VK_ARM_TLSLDO) |
Dylan McKay | ba23343 | 2017-12-09 08:01:28 +0000 | [diff] [blame] | 399 | .Case("lo8", VK_AVR_LO8) |
| 400 | .Case("hi8", VK_AVR_HI8) |
| 401 | .Case("hlo8", VK_AVR_HLO8) |
Konstantin Zhuravlyov | 2a2ac37 | 2016-10-14 04:21:32 +0000 | [diff] [blame] | 402 | .Case("gotpcrel32@lo", VK_AMDGPU_GOTPCREL32_LO) |
| 403 | .Case("gotpcrel32@hi", VK_AMDGPU_GOTPCREL32_HI) |
| 404 | .Case("rel32@lo", VK_AMDGPU_REL32_LO) |
| 405 | .Case("rel32@hi", VK_AMDGPU_REL32_HI) |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 406 | .Default(VK_Invalid); |
| 407 | } |
| 408 | |
Benjamin Kramer | dd13643 | 2014-10-11 17:57:27 +0000 | [diff] [blame] | 409 | void MCSymbolRefExpr::printVariantKind(raw_ostream &OS) const { |
| 410 | if (UseParensForSymbolVariant) |
| 411 | OS << '(' << MCSymbolRefExpr::getVariantKindName(getKind()) << ')'; |
| 412 | else |
| 413 | OS << '@' << MCSymbolRefExpr::getVariantKindName(getKind()); |
| 414 | } |
| 415 | |
Daniel Dunbar | 5599256 | 2010-03-15 23:51:06 +0000 | [diff] [blame] | 416 | /* *** */ |
| 417 | |
Craig Topper | 2a6a08b | 2012-09-26 06:36:36 +0000 | [diff] [blame] | 418 | void MCTargetExpr::anchor() {} |
Chris Lattner | 6a833f6 | 2009-09-16 01:26:31 +0000 | [diff] [blame] | 419 | |
Daniel Dunbar | f363645 | 2009-08-31 08:07:22 +0000 | [diff] [blame] | 420 | /* *** */ |
| 421 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 422 | bool MCExpr::evaluateAsAbsolute(int64_t &Res) const { |
| 423 | return evaluateAsAbsolute(Res, nullptr, nullptr, nullptr); |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 424 | } |
| 425 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 426 | bool MCExpr::evaluateAsAbsolute(int64_t &Res, |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 427 | const MCAsmLayout &Layout) const { |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 428 | return evaluateAsAbsolute(Res, &Layout.getAssembler(), &Layout, nullptr); |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 429 | } |
| 430 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 431 | bool MCExpr::evaluateAsAbsolute(int64_t &Res, |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 432 | const MCAsmLayout &Layout, |
| 433 | const SectionAddrMap &Addrs) const { |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 434 | return evaluateAsAbsolute(Res, &Layout.getAssembler(), &Layout, &Addrs); |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 435 | } |
| 436 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 437 | bool MCExpr::evaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm) const { |
| 438 | return evaluateAsAbsolute(Res, &Asm, nullptr, nullptr); |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 439 | } |
| 440 | |
Rafael Espindola | dbb4021 | 2015-03-25 00:25:37 +0000 | [diff] [blame] | 441 | bool MCExpr::evaluateKnownAbsolute(int64_t &Res, |
| 442 | const MCAsmLayout &Layout) const { |
| 443 | return evaluateAsAbsolute(Res, &Layout.getAssembler(), &Layout, nullptr, |
| 444 | true); |
Rafael Espindola | adbe024 | 2014-08-15 14:20:32 +0000 | [diff] [blame] | 445 | } |
| 446 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 447 | bool MCExpr::evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm, |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 448 | const MCAsmLayout *Layout, |
Rafael Espindola | 93e3cf0 | 2010-12-07 00:27:36 +0000 | [diff] [blame] | 449 | const SectionAddrMap *Addrs) const { |
Rafael Espindola | adbe024 | 2014-08-15 14:20:32 +0000 | [diff] [blame] | 450 | // FIXME: The use if InSet = Addrs is a hack. Setting InSet causes us |
| 451 | // absolutize differences across sections and that is what the MachO writer |
| 452 | // uses Addrs for. |
| 453 | return evaluateAsAbsolute(Res, Asm, Layout, Addrs, Addrs); |
| 454 | } |
| 455 | |
| 456 | bool MCExpr::evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm, |
| 457 | const MCAsmLayout *Layout, |
| 458 | const SectionAddrMap *Addrs, bool InSet) const { |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 459 | MCValue Value; |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 460 | |
Daniel Dunbar | 5cfb587 | 2010-03-23 23:47:07 +0000 | [diff] [blame] | 461 | // Fast path constants. |
| 462 | if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(this)) { |
| 463 | Res = CE->getValue(); |
| 464 | return true; |
| 465 | } |
| 466 | |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 467 | bool IsRelocatable = |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 468 | evaluateAsRelocatableImpl(Value, Asm, Layout, nullptr, Addrs, InSet); |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 469 | |
Rafael Espindola | 4124ab1 | 2010-12-22 22:16:24 +0000 | [diff] [blame] | 470 | // Record the current value. |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 471 | Res = Value.getConstant(); |
Rafael Espindola | 4124ab1 | 2010-12-22 22:16:24 +0000 | [diff] [blame] | 472 | |
| 473 | return IsRelocatable && Value.isAbsolute(); |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 474 | } |
| 475 | |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 476 | /// \brief Helper method for \see EvaluateSymbolAdd(). |
Rafael Espindola | 59f90b2 | 2015-03-25 19:24:39 +0000 | [diff] [blame] | 477 | static void AttemptToFoldSymbolOffsetDifference( |
| 478 | const MCAssembler *Asm, const MCAsmLayout *Layout, |
| 479 | const SectionAddrMap *Addrs, bool InSet, const MCSymbolRefExpr *&A, |
| 480 | const MCSymbolRefExpr *&B, int64_t &Addend) { |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 481 | if (!A || !B) |
| 482 | return; |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 483 | |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 484 | const MCSymbol &SA = A->getSymbol(); |
| 485 | const MCSymbol &SB = B->getSymbol(); |
| 486 | |
| 487 | if (SA.isUndefined() || SB.isUndefined()) |
| 488 | return; |
| 489 | |
Jim Grosbach | 36e60e9 | 2015-06-04 22:24:41 +0000 | [diff] [blame] | 490 | if (!Asm->getWriter().isSymbolRefDifferenceFullyResolved(*Asm, A, B, InSet)) |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 491 | return; |
| 492 | |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 493 | if (SA.getFragment() == SB.getFragment() && !SA.isVariable() && |
| 494 | !SB.isVariable()) { |
Rafael Espindola | 1467250 | 2015-05-29 17:48:04 +0000 | [diff] [blame] | 495 | Addend += (SA.getOffset() - SB.getOffset()); |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 496 | |
Owen Anderson | 9746286 | 2011-03-21 23:13:43 +0000 | [diff] [blame] | 497 | // Pointers to Thumb symbols need to have their low-bit set to allow |
| 498 | // for interworking. |
| 499 | if (Asm->isThumbFunc(&SA)) |
| 500 | Addend |= 1; |
| 501 | |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 502 | // Clear the symbol expr pointers to indicate we have folded these |
| 503 | // operands. |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 504 | A = B = nullptr; |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 505 | return; |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 506 | } |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 507 | |
| 508 | if (!Layout) |
| 509 | return; |
| 510 | |
Rafael Espindola | 4d37b2a | 2015-05-29 21:45:01 +0000 | [diff] [blame] | 511 | const MCSection &SecA = *SA.getFragment()->getParent(); |
| 512 | const MCSection &SecB = *SB.getFragment()->getParent(); |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 513 | |
| 514 | if ((&SecA != &SecB) && !Addrs) |
| 515 | return; |
| 516 | |
| 517 | // Eagerly evaluate. |
Duncan P. N. Exon Smith | 2a40483 | 2015-05-19 23:53:20 +0000 | [diff] [blame] | 518 | Addend += Layout->getSymbolOffset(A->getSymbol()) - |
| 519 | Layout->getSymbolOffset(B->getSymbol()); |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 520 | if (Addrs && (&SecA != &SecB)) |
Rafael Espindola | 079027e | 2015-05-26 00:52:18 +0000 | [diff] [blame] | 521 | Addend += (Addrs->lookup(&SecA) - Addrs->lookup(&SecB)); |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 522 | |
Jim Grosbach | 213039a | 2012-02-24 05:12:18 +0000 | [diff] [blame] | 523 | // Pointers to Thumb symbols need to have their low-bit set to allow |
| 524 | // for interworking. |
| 525 | if (Asm->isThumbFunc(&SA)) |
| 526 | Addend |= 1; |
| 527 | |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 528 | // Clear the symbol expr pointers to indicate we have folded these |
| 529 | // operands. |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 530 | A = B = nullptr; |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 531 | } |
| 532 | |
Daniel Dunbar | 395a099 | 2010-12-16 18:36:25 +0000 | [diff] [blame] | 533 | /// \brief Evaluate the result of an add between (conceptually) two MCValues. |
| 534 | /// |
| 535 | /// This routine conceptually attempts to construct an MCValue: |
| 536 | /// Result = (Result_A - Result_B + Result_Cst) |
| 537 | /// from two MCValue's LHS and RHS where |
| 538 | /// Result = LHS + RHS |
| 539 | /// and |
| 540 | /// Result = (LHS_A - LHS_B + LHS_Cst) + (RHS_A - RHS_B + RHS_Cst). |
| 541 | /// |
| 542 | /// This routine attempts to aggresively fold the operands such that the result |
| 543 | /// is representable in an MCValue, but may not always succeed. |
| 544 | /// |
| 545 | /// \returns True on success, false if the result is not representable in an |
| 546 | /// MCValue. |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 547 | |
| 548 | /// NOTE: It is really important to have both the Asm and Layout arguments. |
| 549 | /// They might look redundant, but this function can be used before layout |
| 550 | /// is done (see the object streamer for example) and having the Asm argument |
Rafael Espindola | 1ea7f18 | 2010-12-18 04:01:45 +0000 | [diff] [blame] | 551 | /// lets us avoid relaxations early. |
Rafael Espindola | 59f90b2 | 2015-03-25 19:24:39 +0000 | [diff] [blame] | 552 | static bool |
| 553 | EvaluateSymbolicAdd(const MCAssembler *Asm, const MCAsmLayout *Layout, |
| 554 | const SectionAddrMap *Addrs, bool InSet, const MCValue &LHS, |
| 555 | const MCSymbolRefExpr *RHS_A, const MCSymbolRefExpr *RHS_B, |
| 556 | int64_t RHS_Cst, MCValue &Res) { |
Daniel Dunbar | 76793ba | 2010-12-17 01:07:20 +0000 | [diff] [blame] | 557 | // FIXME: This routine (and other evaluation parts) are *incredibly* sloppy |
| 558 | // about dealing with modifiers. This will ultimately bite us, one day. |
| 559 | const MCSymbolRefExpr *LHS_A = LHS.getSymA(); |
| 560 | const MCSymbolRefExpr *LHS_B = LHS.getSymB(); |
| 561 | int64_t LHS_Cst = LHS.getConstant(); |
| 562 | |
| 563 | // Fold the result constant immediately. |
| 564 | int64_t Result_Cst = LHS_Cst + RHS_Cst; |
| 565 | |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 566 | assert((!Layout || Asm) && |
| 567 | "Must have an assembler object if layout is given!"); |
| 568 | |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 569 | // If we have a layout, we can fold resolved differences. |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 570 | if (Asm) { |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 571 | // First, fold out any differences which are fully resolved. By |
| 572 | // reassociating terms in |
| 573 | // Result = (LHS_A - LHS_B + LHS_Cst) + (RHS_A - RHS_B + RHS_Cst). |
| 574 | // we have the four possible differences: |
| 575 | // (LHS_A - LHS_B), |
| 576 | // (LHS_A - RHS_B), |
| 577 | // (RHS_A - LHS_B), |
| 578 | // (RHS_A - RHS_B). |
Chris Lattner | 0ab5e2c | 2011-04-15 05:18:47 +0000 | [diff] [blame] | 579 | // Since we are attempting to be as aggressive as possible about folding, we |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 580 | // attempt to evaluate each possible alternative. |
Rafael Espindola | ee54636 | 2010-12-19 04:18:56 +0000 | [diff] [blame] | 581 | AttemptToFoldSymbolOffsetDifference(Asm, Layout, Addrs, InSet, LHS_A, LHS_B, |
| 582 | Result_Cst); |
| 583 | AttemptToFoldSymbolOffsetDifference(Asm, Layout, Addrs, InSet, LHS_A, RHS_B, |
| 584 | Result_Cst); |
| 585 | AttemptToFoldSymbolOffsetDifference(Asm, Layout, Addrs, InSet, RHS_A, LHS_B, |
| 586 | Result_Cst); |
| 587 | AttemptToFoldSymbolOffsetDifference(Asm, Layout, Addrs, InSet, RHS_A, RHS_B, |
| 588 | Result_Cst); |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 589 | } |
| 590 | |
Daniel Dunbar | 76793ba | 2010-12-17 01:07:20 +0000 | [diff] [blame] | 591 | // We can't represent the addition or subtraction of two symbols. |
| 592 | if ((LHS_A && RHS_A) || (LHS_B && RHS_B)) |
Daniel Dunbar | 19f847f | 2009-06-30 02:08:27 +0000 | [diff] [blame] | 593 | return false; |
| 594 | |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 595 | // At this point, we have at most one additive symbol and one subtractive |
| 596 | // symbol -- find them. |
Daniel Dunbar | 76793ba | 2010-12-17 01:07:20 +0000 | [diff] [blame] | 597 | const MCSymbolRefExpr *A = LHS_A ? LHS_A : RHS_A; |
| 598 | const MCSymbolRefExpr *B = LHS_B ? LHS_B : RHS_B; |
Daniel Dunbar | 137d422 | 2010-12-17 05:50:33 +0000 | [diff] [blame] | 599 | |
Daniel Dunbar | 76793ba | 2010-12-17 01:07:20 +0000 | [diff] [blame] | 600 | Res = MCValue::get(A, B, Result_Cst); |
Daniel Dunbar | 19f847f | 2009-06-30 02:08:27 +0000 | [diff] [blame] | 601 | return true; |
| 602 | } |
| 603 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 604 | bool MCExpr::evaluateAsRelocatable(MCValue &Res, |
Joerg Sonnenberger | 752b91b | 2014-08-10 11:35:12 +0000 | [diff] [blame] | 605 | const MCAsmLayout *Layout, |
Joerg Sonnenberger | b696d46 | 2014-08-10 11:37:07 +0000 | [diff] [blame] | 606 | const MCFixup *Fixup) const { |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 607 | MCAssembler *Assembler = Layout ? &Layout->getAssembler() : nullptr; |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 608 | return evaluateAsRelocatableImpl(Res, Assembler, Layout, Fixup, nullptr, |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 609 | false); |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 610 | } |
| 611 | |
Rafael Espindola | aeed3cb | 2015-03-26 21:11:00 +0000 | [diff] [blame] | 612 | bool MCExpr::evaluateAsValue(MCValue &Res, const MCAsmLayout &Layout) const { |
| 613 | MCAssembler *Assembler = &Layout.getAssembler(); |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 614 | return evaluateAsRelocatableImpl(Res, Assembler, &Layout, nullptr, nullptr, |
Rafael Espindola | aeed3cb | 2015-03-26 21:11:00 +0000 | [diff] [blame] | 615 | true); |
| 616 | } |
| 617 | |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 618 | static bool canExpand(const MCSymbol &Sym, bool InSet) { |
Rafael Espindola | 212fdde | 2015-06-03 21:52:06 +0000 | [diff] [blame] | 619 | const MCExpr *Expr = Sym.getVariableValue(); |
| 620 | const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr); |
| 621 | if (Inner) { |
| 622 | if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF) |
| 623 | return false; |
| 624 | } |
| 625 | |
Rafael Espindola | aeed3cb | 2015-03-26 21:11:00 +0000 | [diff] [blame] | 626 | if (InSet) |
| 627 | return true; |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 628 | return !Sym.isInSection(); |
Rafael Espindola | bc91d7e | 2014-04-28 20:53:11 +0000 | [diff] [blame] | 629 | } |
| 630 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 631 | bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, |
Rafael Espindola | 4262a22 | 2010-10-16 18:23:53 +0000 | [diff] [blame] | 632 | const MCAsmLayout *Layout, |
Joerg Sonnenberger | 752b91b | 2014-08-10 11:35:12 +0000 | [diff] [blame] | 633 | const MCFixup *Fixup, |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 634 | const SectionAddrMap *Addrs, |
| 635 | bool InSet) const { |
Daniel Dunbar | 5376c2a | 2010-03-23 23:47:14 +0000 | [diff] [blame] | 636 | ++stats::MCExprEvaluate; |
| 637 | |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 638 | switch (getKind()) { |
Chris Lattner | 38d022e | 2010-02-08 19:41:07 +0000 | [diff] [blame] | 639 | case Target: |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 640 | return cast<MCTargetExpr>(this)->evaluateAsRelocatableImpl(Res, Layout, |
Joerg Sonnenberger | 752b91b | 2014-08-10 11:35:12 +0000 | [diff] [blame] | 641 | Fixup); |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 642 | |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 643 | case Constant: |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 644 | Res = MCValue::get(cast<MCConstantExpr>(this)->getValue()); |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 645 | return true; |
| 646 | |
| 647 | case SymbolRef: { |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 648 | const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(this); |
| 649 | const MCSymbol &Sym = SRE->getSymbol(); |
Daniel Dunbar | 17b9027 | 2009-10-16 01:33:57 +0000 | [diff] [blame] | 650 | |
| 651 | // Evaluate recursively if this is a variable. |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 652 | if (Sym.isVariable() && SRE->getKind() == MCSymbolRefExpr::VK_None && |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 653 | canExpand(Sym, InSet)) { |
Rafael Espindola | aeed3cb | 2015-03-26 21:11:00 +0000 | [diff] [blame] | 654 | bool IsMachO = SRE->hasSubsectionsViaSymbols(); |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 655 | if (Sym.getVariableValue()->evaluateAsRelocatableImpl( |
Rafael Espindola | aeed3cb | 2015-03-26 21:11:00 +0000 | [diff] [blame] | 656 | Res, Asm, Layout, Fixup, Addrs, InSet || IsMachO)) { |
| 657 | if (!IsMachO) |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 658 | return true; |
| 659 | |
Rafael Espindola | 7fadc0e | 2014-03-20 02:12:01 +0000 | [diff] [blame] | 660 | const MCSymbolRefExpr *A = Res.getSymA(); |
| 661 | const MCSymbolRefExpr *B = Res.getSymB(); |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 662 | // FIXME: This is small hack. Given |
| 663 | // a = b + 4 |
| 664 | // .long a |
| 665 | // the OS X assembler will completely drop the 4. We should probably |
| 666 | // include it in the relocation or produce an error if that is not |
| 667 | // possible. |
Evgeniy Stepanov | 60d411b | 2017-06-08 20:49:03 +0000 | [diff] [blame] | 668 | // Allow constant expressions. |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 669 | if (!A && !B) |
| 670 | return true; |
Evgeniy Stepanov | 60d411b | 2017-06-08 20:49:03 +0000 | [diff] [blame] | 671 | // Allows aliases with zero offset. |
| 672 | if (Res.getConstant() == 0 && (!A || !B)) |
| 673 | return true; |
Rafael Espindola | 7fadc0e | 2014-03-20 02:12:01 +0000 | [diff] [blame] | 674 | } |
Rafael Espindola | 8c3039b | 2010-11-15 16:33:49 +0000 | [diff] [blame] | 675 | } |
Daniel Dunbar | 17b9027 | 2009-10-16 01:33:57 +0000 | [diff] [blame] | 676 | |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 677 | Res = MCValue::get(SRE, nullptr, 0); |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 678 | return true; |
| 679 | } |
| 680 | |
| 681 | case Unary: { |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 682 | const MCUnaryExpr *AUE = cast<MCUnaryExpr>(this); |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 683 | MCValue Value; |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 684 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 685 | if (!AUE->getSubExpr()->evaluateAsRelocatableImpl(Value, Asm, Layout, Fixup, |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 686 | Addrs, InSet)) |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 687 | return false; |
| 688 | |
| 689 | switch (AUE->getOpcode()) { |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 690 | case MCUnaryExpr::LNot: |
Daniel Dunbar | 0d5fc9a | 2009-07-01 06:48:00 +0000 | [diff] [blame] | 691 | if (!Value.isAbsolute()) |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 692 | return false; |
| 693 | Res = MCValue::get(!Value.getConstant()); |
| 694 | break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 695 | case MCUnaryExpr::Minus: |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 696 | /// -(a - b + const) ==> (b - a - const) |
Daniel Dunbar | 7f8a9eb | 2009-08-11 17:47:52 +0000 | [diff] [blame] | 697 | if (Value.getSymA() && !Value.getSymB()) |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 698 | return false; |
Sanjay Patel | 42bbe77 | 2016-05-20 14:09:41 +0000 | [diff] [blame] | 699 | |
| 700 | // The cast avoids undefined behavior if the constant is INT64_MIN. |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 701 | Res = MCValue::get(Value.getSymB(), Value.getSymA(), |
Sanjay Patel | 42bbe77 | 2016-05-20 14:09:41 +0000 | [diff] [blame] | 702 | -(uint64_t)Value.getConstant()); |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 703 | break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 704 | case MCUnaryExpr::Not: |
Daniel Dunbar | 0d5fc9a | 2009-07-01 06:48:00 +0000 | [diff] [blame] | 705 | if (!Value.isAbsolute()) |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 706 | return false; |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 707 | Res = MCValue::get(~Value.getConstant()); |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 708 | break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 709 | case MCUnaryExpr::Plus: |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 710 | Res = Value; |
| 711 | break; |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 712 | } |
| 713 | |
| 714 | return true; |
| 715 | } |
| 716 | |
| 717 | case Binary: { |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 718 | const MCBinaryExpr *ABE = cast<MCBinaryExpr>(this); |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 719 | MCValue LHSValue, RHSValue; |
Daniel Dunbar | 9c64ec0 | 2010-03-18 00:59:10 +0000 | [diff] [blame] | 720 | |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 721 | if (!ABE->getLHS()->evaluateAsRelocatableImpl(LHSValue, Asm, Layout, Fixup, |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 722 | Addrs, InSet) || |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 723 | !ABE->getRHS()->evaluateAsRelocatableImpl(RHSValue, Asm, Layout, Fixup, |
Rafael Espindola | f275ad8 | 2015-03-25 13:16:53 +0000 | [diff] [blame] | 724 | Addrs, InSet)) |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 725 | return false; |
| 726 | |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 727 | // We only support a few operations on non-constant expressions, handle |
| 728 | // those first. |
Daniel Dunbar | 0d5fc9a | 2009-07-01 06:48:00 +0000 | [diff] [blame] | 729 | if (!LHSValue.isAbsolute() || !RHSValue.isAbsolute()) { |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 730 | switch (ABE->getOpcode()) { |
| 731 | default: |
| 732 | return false; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 733 | case MCBinaryExpr::Sub: |
Daniel Dunbar | 19f847f | 2009-06-30 02:08:27 +0000 | [diff] [blame] | 734 | // Negate RHS and add. |
Sanjay Patel | 42bbe77 | 2016-05-20 14:09:41 +0000 | [diff] [blame] | 735 | // The cast avoids undefined behavior if the constant is INT64_MIN. |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 736 | return EvaluateSymbolicAdd(Asm, Layout, Addrs, InSet, LHSValue, |
Daniel Dunbar | 19f847f | 2009-06-30 02:08:27 +0000 | [diff] [blame] | 737 | RHSValue.getSymB(), RHSValue.getSymA(), |
Sanjay Patel | 42bbe77 | 2016-05-20 14:09:41 +0000 | [diff] [blame] | 738 | -(uint64_t)RHSValue.getConstant(), Res); |
Daniel Dunbar | 19f847f | 2009-06-30 02:08:27 +0000 | [diff] [blame] | 739 | |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 740 | case MCBinaryExpr::Add: |
Rafael Espindola | 5004f4a | 2010-12-18 03:57:21 +0000 | [diff] [blame] | 741 | return EvaluateSymbolicAdd(Asm, Layout, Addrs, InSet, LHSValue, |
Daniel Dunbar | 19f847f | 2009-06-30 02:08:27 +0000 | [diff] [blame] | 742 | RHSValue.getSymA(), RHSValue.getSymB(), |
Rafael Espindola | 59f90b2 | 2015-03-25 19:24:39 +0000 | [diff] [blame] | 743 | RHSValue.getConstant(), Res); |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 744 | } |
| 745 | } |
| 746 | |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 747 | // FIXME: We need target hooks for the evaluation. It may be limited in |
Ahmed Bougacha | 177c148 | 2015-04-28 00:21:32 +0000 | [diff] [blame] | 748 | // width, and gas defines the result of comparisons differently from |
| 749 | // Apple as. |
Daniel Dunbar | 3971273 | 2009-06-30 16:02:47 +0000 | [diff] [blame] | 750 | int64_t LHS = LHSValue.getConstant(), RHS = RHSValue.getConstant(); |
| 751 | int64_t Result = 0; |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 752 | switch (ABE->getOpcode()) { |
Ahmed Bougacha | 177c148 | 2015-04-28 00:21:32 +0000 | [diff] [blame] | 753 | case MCBinaryExpr::AShr: Result = LHS >> RHS; break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 754 | case MCBinaryExpr::Add: Result = LHS + RHS; break; |
| 755 | case MCBinaryExpr::And: Result = LHS & RHS; break; |
Davide Italiano | 983366a | 2015-09-11 22:04:21 +0000 | [diff] [blame] | 756 | case MCBinaryExpr::Div: |
Simon Pilgrim | 8831f6e | 2018-02-22 18:06:48 +0000 | [diff] [blame] | 757 | case MCBinaryExpr::Mod: |
Davide Italiano | 63cee81 | 2015-09-11 20:47:35 +0000 | [diff] [blame] | 758 | // Handle division by zero. gas just emits a warning and keeps going, |
| 759 | // we try to be stricter. |
| 760 | // FIXME: Currently the caller of this function has no way to understand |
| 761 | // we're bailing out because of 'division by zero'. Therefore, it will |
| 762 | // emit a 'expected relocatable expression' error. It would be nice to |
| 763 | // change this code to emit a better diagnostic. |
| 764 | if (RHS == 0) |
| 765 | return false; |
Simon Pilgrim | 8831f6e | 2018-02-22 18:06:48 +0000 | [diff] [blame] | 766 | if (ABE->getOpcode() == MCBinaryExpr::Div) |
| 767 | Result = LHS / RHS; |
| 768 | else |
| 769 | Result = LHS % RHS; |
Davide Italiano | 983366a | 2015-09-11 22:04:21 +0000 | [diff] [blame] | 770 | break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 771 | case MCBinaryExpr::EQ: Result = LHS == RHS; break; |
| 772 | case MCBinaryExpr::GT: Result = LHS > RHS; break; |
| 773 | case MCBinaryExpr::GTE: Result = LHS >= RHS; break; |
| 774 | case MCBinaryExpr::LAnd: Result = LHS && RHS; break; |
| 775 | case MCBinaryExpr::LOr: Result = LHS || RHS; break; |
Ahmed Bougacha | 177c148 | 2015-04-28 00:21:32 +0000 | [diff] [blame] | 776 | case MCBinaryExpr::LShr: Result = uint64_t(LHS) >> uint64_t(RHS); break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 777 | case MCBinaryExpr::LT: Result = LHS < RHS; break; |
| 778 | case MCBinaryExpr::LTE: Result = LHS <= RHS; break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 779 | case MCBinaryExpr::Mul: Result = LHS * RHS; break; |
| 780 | case MCBinaryExpr::NE: Result = LHS != RHS; break; |
| 781 | case MCBinaryExpr::Or: Result = LHS | RHS; break; |
Justin Bogner | c160215 | 2015-06-23 07:32:55 +0000 | [diff] [blame] | 782 | case MCBinaryExpr::Shl: Result = uint64_t(LHS) << uint64_t(RHS); break; |
Daniel Dunbar | 115e4d6 | 2009-08-31 08:06:59 +0000 | [diff] [blame] | 783 | case MCBinaryExpr::Sub: Result = LHS - RHS; break; |
| 784 | case MCBinaryExpr::Xor: Result = LHS ^ RHS; break; |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 785 | } |
| 786 | |
Daniel Dunbar | bd4bf3d | 2009-06-30 01:49:52 +0000 | [diff] [blame] | 787 | Res = MCValue::get(Result); |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 788 | return true; |
| 789 | } |
| 790 | } |
Daniel Dunbar | 84bfd7b | 2009-06-29 20:40:36 +0000 | [diff] [blame] | 791 | |
Craig Topper | a2886c2 | 2012-02-07 05:05:23 +0000 | [diff] [blame] | 792 | llvm_unreachable("Invalid assembly expression kind!"); |
Daniel Dunbar | f363645 | 2009-08-31 08:07:22 +0000 | [diff] [blame] | 793 | } |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 794 | |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 795 | MCFragment *MCExpr::findAssociatedFragment() const { |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 796 | switch (getKind()) { |
| 797 | case Target: |
| 798 | // We never look through target specific expressions. |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 799 | return cast<MCTargetExpr>(this)->findAssociatedFragment(); |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 800 | |
| 801 | case Constant: |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 802 | return MCSymbol::AbsolutePseudoFragment; |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 803 | |
| 804 | case SymbolRef: { |
| 805 | const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(this); |
| 806 | const MCSymbol &Sym = SRE->getSymbol(); |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 807 | return Sym.getFragment(); |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 808 | } |
| 809 | |
| 810 | case Unary: |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 811 | return cast<MCUnaryExpr>(this)->getSubExpr()->findAssociatedFragment(); |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 812 | |
| 813 | case Binary: { |
| 814 | const MCBinaryExpr *BE = cast<MCBinaryExpr>(this); |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 815 | MCFragment *LHS_F = BE->getLHS()->findAssociatedFragment(); |
| 816 | MCFragment *RHS_F = BE->getRHS()->findAssociatedFragment(); |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 817 | |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 818 | // If either is absolute, return the other. |
| 819 | if (LHS_F == MCSymbol::AbsolutePseudoFragment) |
| 820 | return RHS_F; |
| 821 | if (RHS_F == MCSymbol::AbsolutePseudoFragment) |
| 822 | return LHS_F; |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 823 | |
Peter Collingbourne | 10d362c | 2015-04-03 01:46:11 +0000 | [diff] [blame] | 824 | // Not always correct, but probably the best we can do without more context. |
| 825 | if (BE->getOpcode() == MCBinaryExpr::Sub) |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 826 | return MCSymbol::AbsolutePseudoFragment; |
Peter Collingbourne | 10d362c | 2015-04-03 01:46:11 +0000 | [diff] [blame] | 827 | |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 828 | // Otherwise, return the first non-null fragment. |
| 829 | return LHS_F ? LHS_F : RHS_F; |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 830 | } |
| 831 | } |
| 832 | |
Craig Topper | a2886c2 | 2012-02-07 05:05:23 +0000 | [diff] [blame] | 833 | llvm_unreachable("Invalid assembly expression kind!"); |
Daniel Dunbar | dc3e4cc | 2011-04-29 18:00:03 +0000 | [diff] [blame] | 834 | } |