MCExpr.cpp revision 199481
1//===- MCExpr.cpp - Assembly Level Expression Implementation --------------===// 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 10#include "llvm/MC/MCExpr.h" 11#include "llvm/MC/MCContext.h" 12#include "llvm/MC/MCSymbol.h" 13#include "llvm/MC/MCValue.h" 14#include "llvm/Support/raw_ostream.h" 15using namespace llvm; 16 17void MCExpr::print(raw_ostream &OS, const MCAsmInfo *MAI) const { 18 switch (getKind()) { 19 case MCExpr::Constant: 20 OS << cast<MCConstantExpr>(*this).getValue(); 21 return; 22 23 case MCExpr::SymbolRef: { 24 const MCSymbol &Sym = cast<MCSymbolRefExpr>(*this).getSymbol(); 25 26 // Parenthesize names that start with $ so that they don't look like 27 // absolute names. 28 if (Sym.getName()[0] == '$') { 29 OS << '('; 30 Sym.print(OS, MAI); 31 OS << ')'; 32 } else { 33 Sym.print(OS, MAI); 34 } 35 return; 36 } 37 38 case MCExpr::Unary: { 39 const MCUnaryExpr &UE = cast<MCUnaryExpr>(*this); 40 switch (UE.getOpcode()) { 41 default: assert(0 && "Invalid opcode!"); 42 case MCUnaryExpr::LNot: OS << '!'; break; 43 case MCUnaryExpr::Minus: OS << '-'; break; 44 case MCUnaryExpr::Not: OS << '~'; break; 45 case MCUnaryExpr::Plus: OS << '+'; break; 46 } 47 UE.getSubExpr()->print(OS, MAI); 48 return; 49 } 50 51 case MCExpr::Binary: { 52 const MCBinaryExpr &BE = cast<MCBinaryExpr>(*this); 53 54 // Only print parens around the LHS if it is non-trivial. 55 if (isa<MCConstantExpr>(BE.getLHS()) || isa<MCSymbolRefExpr>(BE.getLHS())) { 56 BE.getLHS()->print(OS, MAI); 57 } else { 58 OS << '('; 59 BE.getLHS()->print(OS, MAI); 60 OS << ')'; 61 } 62 63 switch (BE.getOpcode()) { 64 default: assert(0 && "Invalid opcode!"); 65 case MCBinaryExpr::Add: 66 // Print "X-42" instead of "X+-42". 67 if (const MCConstantExpr *RHSC = dyn_cast<MCConstantExpr>(BE.getRHS())) { 68 if (RHSC->getValue() < 0) { 69 OS << RHSC->getValue(); 70 return; 71 } 72 } 73 74 OS << '+'; 75 break; 76 case MCBinaryExpr::And: OS << '&'; break; 77 case MCBinaryExpr::Div: OS << '/'; break; 78 case MCBinaryExpr::EQ: OS << "=="; break; 79 case MCBinaryExpr::GT: OS << '>'; break; 80 case MCBinaryExpr::GTE: OS << ">="; break; 81 case MCBinaryExpr::LAnd: OS << "&&"; break; 82 case MCBinaryExpr::LOr: OS << "||"; break; 83 case MCBinaryExpr::LT: OS << '<'; break; 84 case MCBinaryExpr::LTE: OS << "<="; break; 85 case MCBinaryExpr::Mod: OS << '%'; break; 86 case MCBinaryExpr::Mul: OS << '*'; break; 87 case MCBinaryExpr::NE: OS << "!="; break; 88 case MCBinaryExpr::Or: OS << '|'; break; 89 case MCBinaryExpr::Shl: OS << "<<"; break; 90 case MCBinaryExpr::Shr: OS << ">>"; break; 91 case MCBinaryExpr::Sub: OS << '-'; break; 92 case MCBinaryExpr::Xor: OS << '^'; break; 93 } 94 95 // Only print parens around the LHS if it is non-trivial. 96 if (isa<MCConstantExpr>(BE.getRHS()) || isa<MCSymbolRefExpr>(BE.getRHS())) { 97 BE.getRHS()->print(OS, MAI); 98 } else { 99 OS << '('; 100 BE.getRHS()->print(OS, MAI); 101 OS << ')'; 102 } 103 return; 104 } 105 } 106 107 assert(0 && "Invalid expression kind!"); 108} 109 110void MCExpr::dump() const { 111 print(errs(), 0); 112 errs() << '\n'; 113} 114 115/* *** */ 116 117const MCBinaryExpr *MCBinaryExpr::Create(Opcode Opc, const MCExpr *LHS, 118 const MCExpr *RHS, MCContext &Ctx) { 119 return new (Ctx) MCBinaryExpr(Opc, LHS, RHS); 120} 121 122const MCUnaryExpr *MCUnaryExpr::Create(Opcode Opc, const MCExpr *Expr, 123 MCContext &Ctx) { 124 return new (Ctx) MCUnaryExpr(Opc, Expr); 125} 126 127const MCConstantExpr *MCConstantExpr::Create(int64_t Value, MCContext &Ctx) { 128 return new (Ctx) MCConstantExpr(Value); 129} 130 131const MCSymbolRefExpr *MCSymbolRefExpr::Create(const MCSymbol *Sym, 132 MCContext &Ctx) { 133 return new (Ctx) MCSymbolRefExpr(Sym); 134} 135 136const MCSymbolRefExpr *MCSymbolRefExpr::Create(StringRef Name, MCContext &Ctx) { 137 return Create(Ctx.GetOrCreateSymbol(Name), Ctx); 138} 139 140 141/* *** */ 142 143bool MCExpr::EvaluateAsAbsolute(int64_t &Res) const { 144 MCValue Value; 145 146 if (!EvaluateAsRelocatable(Value) || !Value.isAbsolute()) 147 return false; 148 149 Res = Value.getConstant(); 150 return true; 151} 152 153static bool EvaluateSymbolicAdd(const MCValue &LHS, const MCSymbol *RHS_A, 154 const MCSymbol *RHS_B, int64_t RHS_Cst, 155 MCValue &Res) { 156 // We can't add or subtract two symbols. 157 if ((LHS.getSymA() && RHS_A) || 158 (LHS.getSymB() && RHS_B)) 159 return false; 160 161 const MCSymbol *A = LHS.getSymA() ? LHS.getSymA() : RHS_A; 162 const MCSymbol *B = LHS.getSymB() ? LHS.getSymB() : RHS_B; 163 if (B) { 164 // If we have a negated symbol, then we must have also have a non-negated 165 // symbol in order to encode the expression. We can do this check later to 166 // permit expressions which eventually fold to a representable form -- such 167 // as (a + (0 - b)) -- if necessary. 168 if (!A) 169 return false; 170 } 171 Res = MCValue::get(A, B, LHS.getConstant() + RHS_Cst); 172 return true; 173} 174 175bool MCExpr::EvaluateAsRelocatable(MCValue &Res) const { 176 switch (getKind()) { 177 case Constant: 178 Res = MCValue::get(cast<MCConstantExpr>(this)->getValue()); 179 return true; 180 181 case SymbolRef: { 182 const MCSymbol &Sym = cast<MCSymbolRefExpr>(this)->getSymbol(); 183 184 // Evaluate recursively if this is a variable. 185 if (Sym.isVariable()) 186 return Sym.getValue()->EvaluateAsRelocatable(Res); 187 188 Res = MCValue::get(&Sym, 0, 0); 189 return true; 190 } 191 192 case Unary: { 193 const MCUnaryExpr *AUE = cast<MCUnaryExpr>(this); 194 MCValue Value; 195 196 if (!AUE->getSubExpr()->EvaluateAsRelocatable(Value)) 197 return false; 198 199 switch (AUE->getOpcode()) { 200 case MCUnaryExpr::LNot: 201 if (!Value.isAbsolute()) 202 return false; 203 Res = MCValue::get(!Value.getConstant()); 204 break; 205 case MCUnaryExpr::Minus: 206 /// -(a - b + const) ==> (b - a - const) 207 if (Value.getSymA() && !Value.getSymB()) 208 return false; 209 Res = MCValue::get(Value.getSymB(), Value.getSymA(), 210 -Value.getConstant()); 211 break; 212 case MCUnaryExpr::Not: 213 if (!Value.isAbsolute()) 214 return false; 215 Res = MCValue::get(~Value.getConstant()); 216 break; 217 case MCUnaryExpr::Plus: 218 Res = Value; 219 break; 220 } 221 222 return true; 223 } 224 225 case Binary: { 226 const MCBinaryExpr *ABE = cast<MCBinaryExpr>(this); 227 MCValue LHSValue, RHSValue; 228 229 if (!ABE->getLHS()->EvaluateAsRelocatable(LHSValue) || 230 !ABE->getRHS()->EvaluateAsRelocatable(RHSValue)) 231 return false; 232 233 // We only support a few operations on non-constant expressions, handle 234 // those first. 235 if (!LHSValue.isAbsolute() || !RHSValue.isAbsolute()) { 236 switch (ABE->getOpcode()) { 237 default: 238 return false; 239 case MCBinaryExpr::Sub: 240 // Negate RHS and add. 241 return EvaluateSymbolicAdd(LHSValue, 242 RHSValue.getSymB(), RHSValue.getSymA(), 243 -RHSValue.getConstant(), 244 Res); 245 246 case MCBinaryExpr::Add: 247 return EvaluateSymbolicAdd(LHSValue, 248 RHSValue.getSymA(), RHSValue.getSymB(), 249 RHSValue.getConstant(), 250 Res); 251 } 252 } 253 254 // FIXME: We need target hooks for the evaluation. It may be limited in 255 // width, and gas defines the result of comparisons differently from Apple 256 // as (the result is sign extended). 257 int64_t LHS = LHSValue.getConstant(), RHS = RHSValue.getConstant(); 258 int64_t Result = 0; 259 switch (ABE->getOpcode()) { 260 case MCBinaryExpr::Add: Result = LHS + RHS; break; 261 case MCBinaryExpr::And: Result = LHS & RHS; break; 262 case MCBinaryExpr::Div: Result = LHS / RHS; break; 263 case MCBinaryExpr::EQ: Result = LHS == RHS; break; 264 case MCBinaryExpr::GT: Result = LHS > RHS; break; 265 case MCBinaryExpr::GTE: Result = LHS >= RHS; break; 266 case MCBinaryExpr::LAnd: Result = LHS && RHS; break; 267 case MCBinaryExpr::LOr: Result = LHS || RHS; break; 268 case MCBinaryExpr::LT: Result = LHS < RHS; break; 269 case MCBinaryExpr::LTE: Result = LHS <= RHS; break; 270 case MCBinaryExpr::Mod: Result = LHS % RHS; break; 271 case MCBinaryExpr::Mul: Result = LHS * RHS; break; 272 case MCBinaryExpr::NE: Result = LHS != RHS; break; 273 case MCBinaryExpr::Or: Result = LHS | RHS; break; 274 case MCBinaryExpr::Shl: Result = LHS << RHS; break; 275 case MCBinaryExpr::Shr: Result = LHS >> RHS; break; 276 case MCBinaryExpr::Sub: Result = LHS - RHS; break; 277 case MCBinaryExpr::Xor: Result = LHS ^ RHS; break; 278 } 279 280 Res = MCValue::get(Result); 281 return true; 282 } 283 } 284 285 assert(0 && "Invalid assembly expression kind!"); 286 return false; 287} 288