15e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand//===-- PPCAsmParser.cpp - Parse PowerPC asm to MCInst instructions ---------===// 25e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand// 35e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand// The LLVM Compiler Infrastructure 45e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand// 55e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand// This file is distributed under the University of Illinois Open Source 65e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand// License. See LICENSE.TXT for details. 75e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand// 85e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand//===----------------------------------------------------------------------===// 95e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 105e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "MCTargetDesc/PPCMCTargetDesc.h" 11027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand#include "MCTargetDesc/PPCMCExpr.h" 125e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCTargetAsmParser.h" 135e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCStreamer.h" 145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCExpr.h" 155e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCInst.h" 165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCRegisterInfo.h" 175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCSubtargetInfo.h" 185e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCParser/MCAsmLexer.h" 195e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCParser/MCAsmParser.h" 205e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/MC/MCParser/MCParsedAsmOperand.h" 21f63ef914b67593e4b20a0b85e889380c20b41f55Craig Topper#include "llvm/ADT/STLExtras.h" 225e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/ADT/SmallString.h" 235e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/ADT/SmallVector.h" 245e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/ADT/StringSwitch.h" 255e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/ADT/Twine.h" 265e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/Support/SourceMgr.h" 275e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/Support/TargetRegistry.h" 285e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "llvm/Support/raw_ostream.h" 295e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 305e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandusing namespace llvm; 315e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 325e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandnamespace { 335e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned RRegs[32] = { 355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R0, PPC::R1, PPC::R2, PPC::R3, 365e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R4, PPC::R5, PPC::R6, PPC::R7, 375e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R8, PPC::R9, PPC::R10, PPC::R11, 385e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R12, PPC::R13, PPC::R14, PPC::R15, 395e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R16, PPC::R17, PPC::R18, PPC::R19, 405e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R20, PPC::R21, PPC::R22, PPC::R23, 415e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R24, PPC::R25, PPC::R26, PPC::R27, 425e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R28, PPC::R29, PPC::R30, PPC::R31 435e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 445e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned RRegsNoR0[32] = { 455e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::ZERO, 465e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R1, PPC::R2, PPC::R3, 475e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R4, PPC::R5, PPC::R6, PPC::R7, 485e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R8, PPC::R9, PPC::R10, PPC::R11, 495e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R12, PPC::R13, PPC::R14, PPC::R15, 505e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R16, PPC::R17, PPC::R18, PPC::R19, 515e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R20, PPC::R21, PPC::R22, PPC::R23, 525e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R24, PPC::R25, PPC::R26, PPC::R27, 535e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::R28, PPC::R29, PPC::R30, PPC::R31 545e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 555e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned XRegs[32] = { 565e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X0, PPC::X1, PPC::X2, PPC::X3, 575e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X4, PPC::X5, PPC::X6, PPC::X7, 585e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X8, PPC::X9, PPC::X10, PPC::X11, 595e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X12, PPC::X13, PPC::X14, PPC::X15, 605e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X16, PPC::X17, PPC::X18, PPC::X19, 615e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X20, PPC::X21, PPC::X22, PPC::X23, 625e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X24, PPC::X25, PPC::X26, PPC::X27, 635e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X28, PPC::X29, PPC::X30, PPC::X31 645e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 655e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned XRegsNoX0[32] = { 665e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::ZERO8, 675e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X1, PPC::X2, PPC::X3, 685e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X4, PPC::X5, PPC::X6, PPC::X7, 695e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X8, PPC::X9, PPC::X10, PPC::X11, 705e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X12, PPC::X13, PPC::X14, PPC::X15, 715e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X16, PPC::X17, PPC::X18, PPC::X19, 725e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X20, PPC::X21, PPC::X22, PPC::X23, 735e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X24, PPC::X25, PPC::X26, PPC::X27, 745e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::X28, PPC::X29, PPC::X30, PPC::X31 755e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 765e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned FRegs[32] = { 775e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F0, PPC::F1, PPC::F2, PPC::F3, 785e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F4, PPC::F5, PPC::F6, PPC::F7, 795e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F8, PPC::F9, PPC::F10, PPC::F11, 805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F12, PPC::F13, PPC::F14, PPC::F15, 815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F16, PPC::F17, PPC::F18, PPC::F19, 825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F20, PPC::F21, PPC::F22, PPC::F23, 835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F24, PPC::F25, PPC::F26, PPC::F27, 845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::F28, PPC::F29, PPC::F30, PPC::F31 855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned VRegs[32] = { 875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V0, PPC::V1, PPC::V2, PPC::V3, 885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V4, PPC::V5, PPC::V6, PPC::V7, 895e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V8, PPC::V9, PPC::V10, PPC::V11, 905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V12, PPC::V13, PPC::V14, PPC::V15, 915e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V16, PPC::V17, PPC::V18, PPC::V19, 925e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V20, PPC::V21, PPC::V22, PPC::V23, 935e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V24, PPC::V25, PPC::V26, PPC::V27, 945e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::V28, PPC::V29, PPC::V30, PPC::V31 955e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 965e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned CRBITRegs[32] = { 975e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR0LT, PPC::CR0GT, PPC::CR0EQ, PPC::CR0UN, 985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR1LT, PPC::CR1GT, PPC::CR1EQ, PPC::CR1UN, 995e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR2LT, PPC::CR2GT, PPC::CR2EQ, PPC::CR2UN, 1005e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR3LT, PPC::CR3GT, PPC::CR3EQ, PPC::CR3UN, 1015e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR4LT, PPC::CR4GT, PPC::CR4EQ, PPC::CR4UN, 1025e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR5LT, PPC::CR5GT, PPC::CR5EQ, PPC::CR5UN, 1035e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR6LT, PPC::CR6GT, PPC::CR6EQ, PPC::CR6UN, 1045e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR7LT, PPC::CR7GT, PPC::CR7EQ, PPC::CR7UN 1055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 1065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstatic unsigned CRRegs[8] = { 1075e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR0, PPC::CR1, PPC::CR2, PPC::CR3, 1085e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPC::CR4, PPC::CR5, PPC::CR6, PPC::CR7 1095e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 1105e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1115606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand// Evaluate an expression containing condition register 1125606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand// or condition register field symbols. Returns positive 1135606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand// value on success, or -1 on error. 1145606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigandstatic int64_t 1155606fcae50951e9d9aef7def18531b5fd017971bUlrich WeigandEvaluateCRExpr(const MCExpr *E) { 1165606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand switch (E->getKind()) { 1175606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand case MCExpr::Target: 1185606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return -1; 1195606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1205606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand case MCExpr::Constant: { 1215606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand int64_t Res = cast<MCConstantExpr>(E)->getValue(); 1225606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return Res < 0 ? -1 : Res; 1235606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand } 1245606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1255606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand case MCExpr::SymbolRef: { 1265606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 1275606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand StringRef Name = SRE->getSymbol().getName(); 1285606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1295606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "lt") return 0; 1305606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "gt") return 1; 1315606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "eq") return 2; 1325606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "so") return 3; 1335606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "un") return 3; 1345606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1355606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr0") return 0; 1365606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr1") return 1; 1375606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr2") return 2; 1385606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr3") return 3; 1395606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr4") return 4; 1405606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr5") return 5; 1415606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr6") return 6; 1425606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (Name == "cr7") return 7; 1435606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1445606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return -1; 1455606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand } 1465606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1475606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand case MCExpr::Unary: 1485606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return -1; 1495606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1505606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand case MCExpr::Binary: { 1515606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 1525606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand int64_t LHSVal = EvaluateCRExpr(BE->getLHS()); 1535606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand int64_t RHSVal = EvaluateCRExpr(BE->getRHS()); 1545606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand int64_t Res; 1555606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1565606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand if (LHSVal < 0 || RHSVal < 0) 1575606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return -1; 1585606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1595606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand switch (BE->getOpcode()) { 1605606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand default: return -1; 1615606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand case MCBinaryExpr::Add: Res = LHSVal + RHSVal; break; 1625606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand case MCBinaryExpr::Mul: Res = LHSVal * RHSVal; break; 1635606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand } 1645606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1655606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return Res < 0 ? -1 : Res; 1665606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand } 1675606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand } 1685606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1695606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand llvm_unreachable("Invalid expression kind!"); 1705606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand} 1715606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 1725e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstruct PPCOperand; 1735e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1745e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandclass PPCAsmParser : public MCTargetAsmParser { 1755e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand MCSubtargetInfo &STI; 1765e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand MCAsmParser &Parser; 1775e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool IsPPC64; 1785e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1795e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand MCAsmParser &getParser() const { return Parser; } 1805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand MCAsmLexer &getLexer() const { return Parser.getLexer(); } 1815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); } 1835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); } 1845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isPPC64() const { return IsPPC64; } 1865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool MatchRegisterName(const AsmToken &Tok, 1885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand unsigned &RegNo, int64_t &IntVal); 1895e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc); 1915e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 192027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCExpr *ExtractModifierFromExpr(const MCExpr *E, 193027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand PPCMCExpr::VariantKind &Variant); 1947a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand const MCExpr *FixupVariantKind(const MCExpr *E); 195027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand bool ParseExpression(const MCExpr *&EVal); 196027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 1975e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool ParseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands); 1985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1995e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool ParseDirectiveWord(unsigned Size, SMLoc L); 2005e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool ParseDirectiveTC(unsigned Size, SMLoc L); 201b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand bool ParseDirectiveMachine(SMLoc L); 2025e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2035e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, 2045e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SmallVectorImpl<MCParsedAsmOperand*> &Operands, 2055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand MCStreamer &Out, unsigned &ErrorInfo, 2065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool MatchingInlineAsm); 2075e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 20816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand void ProcessInstruction(MCInst &Inst, 20916adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand const SmallVectorImpl<MCParsedAsmOperand*> &Ops); 21016adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand 2115e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand /// @name Auto-generated Match Functions 2125e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand /// { 2135e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#define GET_ASSEMBLER_HEADER 2155e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "PPCGenAsmMatcher.inc" 2165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand /// } 2185e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2195e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2205e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandpublic: 2215e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPCAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser) 2225e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand : MCTargetAsmParser(), STI(_STI), Parser(_Parser) { 2235e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Check for 64-bit vs. 32-bit pointer mode. 2245e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Triple TheTriple(STI.getTargetTriple()); 225f38cc38fa647d4e72c053c39bbe0cdec1342535fBill Schmidt IsPPC64 = (TheTriple.getArch() == Triple::ppc64 || 226f38cc38fa647d4e72c053c39bbe0cdec1342535fBill Schmidt TheTriple.getArch() == Triple::ppc64le); 2275e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Initialize the set of available features. 2285e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits())); 2295e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 2305e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2315e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand virtual bool ParseInstruction(ParseInstructionInfo &Info, 2325e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand StringRef Name, SMLoc NameLoc, 2335e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SmallVectorImpl<MCParsedAsmOperand*> &Operands); 2345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand virtual bool ParseDirective(AsmToken DirectiveID); 2369e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand 2379e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand unsigned validateTargetOperandClass(MCParsedAsmOperand *Op, unsigned Kind); 2385e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 2395e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2405e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// PPCOperand - Instances of this class represent a parsed PowerPC machine 2415e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// instruction. 2425e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandstruct PPCOperand : public MCParsedAsmOperand { 2435e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand enum KindTy { 2445e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Token, 2455e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Immediate, 24623a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Expression, 24723a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand TLSRegister 2485e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } Kind; 2495e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2505e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc StartLoc, EndLoc; 2515e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool IsPPC64; 2525e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2535e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand struct TokOp { 2545e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand const char *Data; 2555e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand unsigned Length; 2565e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand }; 2575e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2585e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand struct ImmOp { 2595e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand int64_t Val; 2605e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand }; 2615e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2625e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand struct ExprOp { 2635e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand const MCExpr *Val; 2645606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand int64_t CRVal; // Cached result of EvaluateCRExpr(Val) 2655e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand }; 2665e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 26723a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand struct TLSRegOp { 26823a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand const MCSymbolRefExpr *Sym; 26923a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand }; 27023a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand 2715e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand union { 2725e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand struct TokOp Tok; 2735e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand struct ImmOp Imm; 2745e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand struct ExprOp Expr; 27523a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand struct TLSRegOp TLSReg; 2765e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand }; 2775e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 2785e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPCOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {} 2795e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandpublic: 2805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPCOperand(const PPCOperand &o) : MCParsedAsmOperand() { 2815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Kind = o.Kind; 2825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand StartLoc = o.StartLoc; 2835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand EndLoc = o.EndLoc; 2845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand IsPPC64 = o.IsPPC64; 2855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand switch (Kind) { 2865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Token: 2875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Tok = o.Tok; 2885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 2895e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Immediate: 2905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Imm = o.Imm; 2915e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 2925e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Expression: 2935e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Expr = o.Expr; 2945e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 29523a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand case TLSRegister: 29623a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand TLSReg = o.TLSReg; 29723a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand break; 2985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 2995e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3005e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3015e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand /// getStartLoc - Get the location of the first token of this operand. 3025e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc getStartLoc() const { return StartLoc; } 3035e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3045e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand /// getEndLoc - Get the location of the last token of this operand. 3055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc getEndLoc() const { return EndLoc; } 3065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3075e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand /// isPPC64 - True if this operand is for an instruction in 64-bit mode. 3085e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isPPC64() const { return IsPPC64; } 3095e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3105e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand int64_t getImm() const { 3115e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(Kind == Immediate && "Invalid access!"); 3125e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Imm.Val; 3135e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3155e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand const MCExpr *getExpr() const { 3165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(Kind == Expression && "Invalid access!"); 3175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Expr.Val; 3185e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3195e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3205606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand int64_t getExprCRVal() const { 3215606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand assert(Kind == Expression && "Invalid access!"); 3225606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return Expr.CRVal; 3235606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand } 3245606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 32523a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand const MCExpr *getTLSReg() const { 32623a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand assert(Kind == TLSRegister && "Invalid access!"); 32723a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand return TLSReg.Sym; 32823a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand } 32923a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand 3305e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand unsigned getReg() const { 3315e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(isRegNumber() && "Invalid access!"); 3325e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return (unsigned) Imm.Val; 3335e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand unsigned getCCReg() const { 3365e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(isCCRegNumber() && "Invalid access!"); 3375606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return (unsigned) (Kind == Immediate ? Imm.Val : Expr.CRVal); 3385606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand } 3395606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand 3405606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand unsigned getCRBit() const { 3415606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand assert(isCRBitNumber() && "Invalid access!"); 3425606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand return (unsigned) (Kind == Immediate ? Imm.Val : Expr.CRVal); 3435e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3445e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3455e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand unsigned getCRBitMask() const { 3465e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(isCRBitMask() && "Invalid access!"); 347c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer return 7 - countTrailingZeros<uint64_t>(Imm.Val); 3485e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3495e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3505e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isToken() const { return Kind == Token; } 3515e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isImm() const { return Kind == Immediate || Kind == Expression; } 3525e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isU5Imm() const { return Kind == Immediate && isUInt<5>(getImm()); } 3535e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isS5Imm() const { return Kind == Immediate && isInt<5>(getImm()); } 3545e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isU6Imm() const { return Kind == Immediate && isUInt<6>(getImm()); } 3555e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isU16Imm() const { return Kind == Expression || 3565e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand (Kind == Immediate && isUInt<16>(getImm())); } 3575e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isS16Imm() const { return Kind == Expression || 3585e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand (Kind == Immediate && isInt<16>(getImm())); } 3595e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isS16ImmX4() const { return Kind == Expression || 3605e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand (Kind == Immediate && isInt<16>(getImm()) && 3615e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand (getImm() & 3) == 0); } 3628950dd127ad4cccd9dadf616b5057cf130f24adeUlrich Weigand bool isS17Imm() const { return Kind == Expression || 3638950dd127ad4cccd9dadf616b5057cf130f24adeUlrich Weigand (Kind == Immediate && isInt<17>(getImm())); } 36423a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand bool isTLSReg() const { return Kind == TLSRegister; } 3659679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand bool isDirectBr() const { return Kind == Expression || 3669679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand (Kind == Immediate && isInt<26>(getImm()) && 3679679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand (getImm() & 3) == 0); } 3689679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand bool isCondBr() const { return Kind == Expression || 3699679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand (Kind == Immediate && isInt<16>(getImm()) && 3709679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand (getImm() & 3) == 0); } 3715e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isRegNumber() const { return Kind == Immediate && isUInt<5>(getImm()); } 3725606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand bool isCCRegNumber() const { return (Kind == Expression 3735606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand && isUInt<3>(getExprCRVal())) || 3745606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand (Kind == Immediate 3755606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand && isUInt<3>(getImm())); } 3765606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand bool isCRBitNumber() const { return (Kind == Expression 3775606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand && isUInt<5>(getExprCRVal())) || 3785606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand (Kind == Immediate 3795606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand && isUInt<5>(getImm())); } 3805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isCRBitMask() const { return Kind == Immediate && isUInt<8>(getImm()) && 3815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand isPowerOf2_32(getImm()); } 3825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isMem() const { return false; } 3835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool isReg() const { return false; } 3845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegOperands(MCInst &Inst, unsigned N) const { 3865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand llvm_unreachable("addRegOperands"); 3875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3895e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegGPRCOperands(MCInst &Inst, unsigned N) const { 3905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 3915e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(RRegs[getReg()])); 3925e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3935e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3945e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegGPRCNoR0Operands(MCInst &Inst, unsigned N) const { 3955e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 3965e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(RRegsNoR0[getReg()])); 3975e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 3985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 3995e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegG8RCOperands(MCInst &Inst, unsigned N) const { 4005e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4015e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(XRegs[getReg()])); 4025e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4035e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4045e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegG8RCNoX0Operands(MCInst &Inst, unsigned N) const { 4055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(XRegsNoX0[getReg()])); 4075e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4085e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4095e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegGxRCOperands(MCInst &Inst, unsigned N) const { 4105e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (isPPC64()) 4115e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand addRegG8RCOperands(Inst, N); 4125e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand else 4135e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand addRegGPRCOperands(Inst, N); 4145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4155e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegGxRCNoR0Operands(MCInst &Inst, unsigned N) const { 4175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (isPPC64()) 4185e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand addRegG8RCNoX0Operands(Inst, N); 4195e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand else 4205e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand addRegGPRCNoR0Operands(Inst, N); 4215e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4225e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4235e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegF4RCOperands(MCInst &Inst, unsigned N) const { 4245e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4255e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(FRegs[getReg()])); 4265e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4275e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4285e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegF8RCOperands(MCInst &Inst, unsigned N) const { 4295e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4305e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(FRegs[getReg()])); 4315e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4325e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4335e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegVRRCOperands(MCInst &Inst, unsigned N) const { 4345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(VRegs[getReg()])); 4365e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4375e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4385e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegCRBITRCOperands(MCInst &Inst, unsigned N) const { 4395e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4405606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand Inst.addOperand(MCOperand::CreateReg(CRBITRegs[getCRBit()])); 4415e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4425e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4435e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addRegCRRCOperands(MCInst &Inst, unsigned N) const { 4445e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4455e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(CRRegs[getCCReg()])); 4465e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4475e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4485e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addCRBitMaskOperands(MCInst &Inst, unsigned N) const { 4495e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4505e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateReg(CRRegs[getCRBitMask()])); 4515e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4525e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4535e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand void addImmOperands(MCInst &Inst, unsigned N) const { 4545e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4555e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (Kind == Immediate) 4565e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateImm(getImm())); 4575e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand else 4585e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.addOperand(MCOperand::CreateExpr(getExpr())); 4595e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4605e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4619679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand void addBranchTargetOperands(MCInst &Inst, unsigned N) const { 4629679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 4639679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand if (Kind == Immediate) 4649679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand Inst.addOperand(MCOperand::CreateImm(getImm() / 4)); 4659679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand else 4669679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand Inst.addOperand(MCOperand::CreateExpr(getExpr())); 4679679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand } 4689679c47a07386cbf3547a0927609c7ee080b2aabUlrich Weigand 46923a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand void addTLSRegOperands(MCInst &Inst, unsigned N) const { 47023a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand assert(N == 1 && "Invalid number of operands!"); 47123a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Inst.addOperand(MCOperand::CreateExpr(getTLSReg())); 47223a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand } 47323a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand 4745e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand StringRef getToken() const { 4755e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand assert(Kind == Token && "Invalid access!"); 4765e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return StringRef(Tok.Data, Tok.Length); 4775e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4785e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4795e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand virtual void print(raw_ostream &OS) const; 4805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 4815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand static PPCOperand *CreateToken(StringRef Str, SMLoc S, bool IsPPC64) { 4825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPCOperand *Op = new PPCOperand(Token); 4835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->Tok.Data = Str.data(); 4845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->Tok.Length = Str.size(); 4855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->StartLoc = S; 4865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->EndLoc = S; 4875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->IsPPC64 = IsPPC64; 4885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Op; 4895e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 4905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 491af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer static PPCOperand *CreateTokenWithStringCopy(StringRef Str, SMLoc S, 492af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer bool IsPPC64) { 493af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer // Allocate extra memory for the string and copy it. 494af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer void *Mem = ::operator new(sizeof(PPCOperand) + Str.size()); 495af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer PPCOperand *Op = new (Mem) PPCOperand(Token); 496af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Op->Tok.Data = (const char *)(Op + 1); 497af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Op->Tok.Length = Str.size(); 498af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer std::memcpy((char *)(Op + 1), Str.data(), Str.size()); 499af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Op->StartLoc = S; 500af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Op->EndLoc = S; 501af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Op->IsPPC64 = IsPPC64; 502af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer return Op; 503af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer } 504af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer 5055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand static PPCOperand *CreateImm(int64_t Val, SMLoc S, SMLoc E, bool IsPPC64) { 5065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPCOperand *Op = new PPCOperand(Immediate); 5075e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->Imm.Val = Val; 5085e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->StartLoc = S; 5095e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->EndLoc = E; 5105e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->IsPPC64 = IsPPC64; 5115e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Op; 5125e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 5135e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 5145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand static PPCOperand *CreateExpr(const MCExpr *Val, 5155e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc S, SMLoc E, bool IsPPC64) { 5165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPCOperand *Op = new PPCOperand(Expression); 5175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->Expr.Val = Val; 5185606fcae50951e9d9aef7def18531b5fd017971bUlrich Weigand Op->Expr.CRVal = EvaluateCRExpr(Val); 5195e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->StartLoc = S; 5205e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->EndLoc = E; 5215e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op->IsPPC64 = IsPPC64; 5225e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Op; 5235e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 52423a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand 52523a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand static PPCOperand *CreateTLSReg(const MCSymbolRefExpr *Sym, 52623a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand SMLoc S, SMLoc E, bool IsPPC64) { 52723a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand PPCOperand *Op = new PPCOperand(TLSRegister); 52823a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Op->TLSReg.Sym = Sym; 52923a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Op->StartLoc = S; 53023a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Op->EndLoc = E; 53123a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Op->IsPPC64 = IsPPC64; 53223a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand return Op; 53323a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand } 53423a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand 53523a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand static PPCOperand *CreateFromMCExpr(const MCExpr *Val, 53623a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand SMLoc S, SMLoc E, bool IsPPC64) { 53723a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Val)) 53823a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand return CreateImm(CE->getValue(), S, E, IsPPC64); 53923a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand 54023a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(Val)) 54123a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand if (SRE->getKind() == MCSymbolRefExpr::VK_PPC_TLS) 54223a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand return CreateTLSReg(SRE, S, E, IsPPC64); 54323a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand 54423a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand return CreateExpr(Val, S, E, IsPPC64); 54523a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand } 5465e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand}; 5475e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 5485e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} // end anonymous namespace. 5495e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 5505e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandvoid PPCOperand::print(raw_ostream &OS) const { 5515e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand switch (Kind) { 5525e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Token: 5535e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand OS << "'" << getToken() << "'"; 5545e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 5555e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Immediate: 5565e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand OS << getImm(); 5575e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 5585e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Expression: 5595e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand getExpr()->print(OS); 5605e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 56123a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand case TLSRegister: 56223a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand getTLSReg()->print(OS); 56323a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand break; 5645e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 5655e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 5665e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 5675e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 56816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigandvoid PPCAsmParser:: 56916adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich WeigandProcessInstruction(MCInst &Inst, 57016adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 5711bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int Opcode = Inst.getOpcode(); 5721bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand switch (Opcode) { 57396fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand case PPC::LAx: { 57496fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand MCInst TmpInst; 57596fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand TmpInst.setOpcode(PPC::LA); 57696fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 57796fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand TmpInst.addOperand(Inst.getOperand(2)); 57896fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 57996fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand Inst = TmpInst; 58096fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand break; 58196fb3a25cb0007f06d22d28c0b9c3503798324f6Ulrich Weigand } 5829c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand case PPC::SUBI: { 5839c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand MCInst TmpInst; 5849c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand int64_t N = Inst.getOperand(2).getImm(); 5859c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.setOpcode(PPC::ADDI); 5869c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 5879c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 5889c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(MCOperand::CreateImm(-N)); 5899c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand Inst = TmpInst; 5909c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand break; 5919c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand } 5929c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand case PPC::SUBIS: { 5939c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand MCInst TmpInst; 5949c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand int64_t N = Inst.getOperand(2).getImm(); 5959c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.setOpcode(PPC::ADDIS); 5969c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 5979c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 5989c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(MCOperand::CreateImm(-N)); 5999c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand Inst = TmpInst; 6009c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand break; 6019c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand } 6029c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand case PPC::SUBIC: { 6039c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand MCInst TmpInst; 6049c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6059c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.setOpcode(PPC::ADDIC); 6069c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6079c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 6089c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(MCOperand::CreateImm(-N)); 6099c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand Inst = TmpInst; 6109c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand break; 6119c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand } 6129c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand case PPC::SUBICo: { 6139c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand MCInst TmpInst; 6149c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6159c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.setOpcode(PPC::ADDICo); 6169c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6179c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 6189c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand TmpInst.addOperand(MCOperand::CreateImm(-N)); 6199c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand Inst = TmpInst; 6209c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand break; 6219c52f81e1787dc9666e510f5b7a0ea75b697cd0bUlrich Weigand } 6221bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTLWI: 6231bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTLWIo: { 62416adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand MCInst TmpInst; 62516adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6261bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(3).getImm(); 6271bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::EXTLWI? PPC::RLWINM : PPC::RLWINMo); 6281bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6291bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 6301bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B)); 6311bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(0)); 6321bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N - 1)); 6331bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 6341bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 6351bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 6361bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTRWI: 6371bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTRWIo: { 6381bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 6391bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6401bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(3).getImm(); 6411bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::EXTRWI? PPC::RLWINM : PPC::RLWINMo); 6421bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6431bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 6441bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B + N)); 6451bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(32 - N)); 6461bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(31)); 6471bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 6481bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 6491bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 6501bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::INSLWI: 6511bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::INSLWIo: { 6521bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 6531bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6541bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(3).getImm(); 6551bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::INSLWI? PPC::RLWIMI : PPC::RLWIMIo); 6561bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6571bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6581bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 6591bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(32 - B)); 6601bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B)); 6611bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm((B + N) - 1)); 6621bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 6631bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 6641bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 6651bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::INSRWI: 6661bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::INSRWIo: { 6671bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 6681bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6691bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(3).getImm(); 6701bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::INSRWI? PPC::RLWIMI : PPC::RLWIMIo); 6711bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6721bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6731bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 6741bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(32 - (B + N))); 6751bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B)); 6761bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm((B + N) - 1)); 6771bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 6781bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 6791bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 6801bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::ROTRWI: 6811bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::ROTRWIo: { 6821bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 6831bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6841bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::ROTRWI? PPC::RLWINM : PPC::RLWINMo); 6851bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 6861bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 6871bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(32 - N)); 6881bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(0)); 6891bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(31)); 6901bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 6911bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 6921bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 6931bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SLWI: 6941bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SLWIo: { 6951bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 6961bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 6971bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::SLWI? PPC::RLWINM : PPC::RLWINMo); 69816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 69916adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 70016adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N)); 70116adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(0)); 70216adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(31 - N)); 70316adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand Inst = TmpInst; 70416adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand break; 70516adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand } 7061bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SRWI: 7071bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SRWIo: { 70816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand MCInst TmpInst; 70916adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 7101bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::SRWI? PPC::RLWINM : PPC::RLWINMo); 71116adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 71216adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 71316adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(32 - N)); 71416adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N)); 71516adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(31)); 71616adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand Inst = TmpInst; 71716adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand break; 71816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand } 7191bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRRWI: 7201bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRRWIo: { 72116adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand MCInst TmpInst; 72216adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 7231bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::CLRRWI? PPC::RLWINM : PPC::RLWINMo); 7241bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 7251bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 7261bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(0)); 7271bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(0)); 7281bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(31 - N)); 7291bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 7301bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 7311bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 7321bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRLSLWI: 7331bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRLSLWIo: { 7341bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 7351bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(2).getImm(); 7361bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(3).getImm(); 7371bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::CLRLSLWI? PPC::RLWINM : PPC::RLWINMo); 7381bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 7391bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 7401bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N)); 7411bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B - N)); 7421bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(31 - N)); 7431bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 7441bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 7451bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 7461bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTLDI: 7471bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTLDIo: { 7481bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 7491bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 7501bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(3).getImm(); 7511bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::EXTLDI? PPC::RLDICR : PPC::RLDICRo); 7521bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 7531bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 7541bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B)); 7551bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N - 1)); 7561bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 7571bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 7581bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 7591bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTRDI: 7601bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::EXTRDIo: { 7611bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 7621bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 7631bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(3).getImm(); 7641bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::EXTRDI? PPC::RLDICL : PPC::RLDICLo); 7651bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 7661bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 7671bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B + N)); 7681bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(64 - N)); 7691bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 7701bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 7711bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 7721bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::INSRDI: 7731bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::INSRDIo: { 7741bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 7751bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 7761bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(3).getImm(); 7771bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::INSRDI? PPC::RLDIMI : PPC::RLDIMIo); 7781bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 7791bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 7801bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 7811bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(64 - (B + N))); 7821bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B)); 7831bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 7841bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 7851bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 7861bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::ROTRDI: 7871bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::ROTRDIo: { 7881bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 7891bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 7901bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::ROTRDI? PPC::RLDICL : PPC::RLDICLo); 7911bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 7921bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 7931bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(64 - N)); 7941bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(0)); 7951bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 7961bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 7971bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 7981bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SLDI: 7991bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SLDIo: { 8001bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 8011bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 8021bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::SLDI? PPC::RLDICR : PPC::RLDICRo); 80316adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 80416adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 80516adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N)); 80616adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(63 - N)); 80716adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand Inst = TmpInst; 80816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand break; 80916adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand } 8101bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SRDI: 8111bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::SRDIo: { 81216adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand MCInst TmpInst; 81316adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 8141bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::SRDI? PPC::RLDICL : PPC::RLDICLo); 81516adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 81616adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 81716adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(64 - N)); 81816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N)); 81916adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand Inst = TmpInst; 82016adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand break; 82116adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand } 8221bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRRDI: 8231bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRRDIo: { 8241bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 8251bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(2).getImm(); 8261bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::CLRRDI? PPC::RLDICR : PPC::RLDICRo); 8271bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 8281bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 8291bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(0)); 8301bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(63 - N)); 8311bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 8321bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 8331bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 8341bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRLSLDI: 8351bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand case PPC::CLRLSLDIo: { 8361bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand MCInst TmpInst; 8371bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t B = Inst.getOperand(2).getImm(); 8381bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand int64_t N = Inst.getOperand(3).getImm(); 8391bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.setOpcode(Opcode == PPC::CLRLSLDI? PPC::RLDIC : PPC::RLDICo); 8401bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(0)); 8411bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(Inst.getOperand(1)); 8421bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(N)); 8431bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand TmpInst.addOperand(MCOperand::CreateImm(B - N)); 8441bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand Inst = TmpInst; 8451bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand break; 8461bc147c0910bb02398730c79e0d0310ffbbd2868Ulrich Weigand } 84716adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand } 84816adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand} 84916adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand 8505e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser:: 8515e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich WeigandMatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, 8525e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SmallVectorImpl<MCParsedAsmOperand*> &Operands, 8535e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand MCStreamer &Out, unsigned &ErrorInfo, 8545e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand bool MatchingInlineAsm) { 8555e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand MCInst Inst; 8565e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 8575e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand switch (MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm)) { 8585e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand default: break; 8595e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Match_Success: 86016adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand // Post-process instructions (typically extended mnemonics) 86116adfdb2e666f46e058b603a8a7aa75758819fd5Ulrich Weigand ProcessInstruction(Inst, Operands); 8625e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Inst.setLoc(IDLoc); 8635e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Out.EmitInstruction(Inst); 8645e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 8655e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Match_MissingFeature: 8665e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(IDLoc, "instruction use requires an option to be enabled"); 8675e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Match_MnemonicFail: 8685e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(IDLoc, "unrecognized instruction mnemonic"); 8695e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case Match_InvalidOperand: { 8705e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc ErrorLoc = IDLoc; 8715e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (ErrorInfo != ~0U) { 8725e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (ErrorInfo >= Operands.size()) 8735e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(IDLoc, "too few operands for instruction"); 8745e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 8755e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand ErrorLoc = ((PPCOperand*)Operands[ErrorInfo])->getStartLoc(); 8765e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 8775e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 8785e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 8795e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(ErrorLoc, "invalid operand for instruction"); 8805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 8815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 8825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 8835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand llvm_unreachable("Implement any new match types added!"); 8845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 8855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 8865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser:: 8875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich WeigandMatchRegisterName(const AsmToken &Tok, unsigned &RegNo, int64_t &IntVal) { 8885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (Tok.is(AsmToken::Identifier)) { 8897d55b6bb1a4a5220ef973cf7b68ae508859a9b71Ulrich Weigand StringRef Name = Tok.getString(); 8905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 8917d55b6bb1a4a5220ef973cf7b68ae508859a9b71Ulrich Weigand if (Name.equals_lower("lr")) { 8925e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegNo = isPPC64()? PPC::LR8 : PPC::LR; 8935e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand IntVal = 8; 8945e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 8957d55b6bb1a4a5220ef973cf7b68ae508859a9b71Ulrich Weigand } else if (Name.equals_lower("ctr")) { 8965e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegNo = isPPC64()? PPC::CTR8 : PPC::CTR; 8975e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand IntVal = 9; 8985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 89975dd57a8f0407be32551cf695e63a106dd051a27Hal Finkel } else if (Name.equals_lower("vrsave")) { 90075dd57a8f0407be32551cf695e63a106dd051a27Hal Finkel RegNo = PPC::VRSAVE; 90175dd57a8f0407be32551cf695e63a106dd051a27Hal Finkel IntVal = 256; 90275dd57a8f0407be32551cf695e63a106dd051a27Hal Finkel return false; 9037d55b6bb1a4a5220ef973cf7b68ae508859a9b71Ulrich Weigand } else if (Name.substr(0, 1).equals_lower("r") && 9045e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) { 9055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegNo = isPPC64()? XRegs[IntVal] : RRegs[IntVal]; 9065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 9077d55b6bb1a4a5220ef973cf7b68ae508859a9b71Ulrich Weigand } else if (Name.substr(0, 1).equals_lower("f") && 9085e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) { 9095e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegNo = FRegs[IntVal]; 9105e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 9117d55b6bb1a4a5220ef973cf7b68ae508859a9b71Ulrich Weigand } else if (Name.substr(0, 1).equals_lower("v") && 9125e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) { 9135e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegNo = VRegs[IntVal]; 9145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 9157d55b6bb1a4a5220ef973cf7b68ae508859a9b71Ulrich Weigand } else if (Name.substr(0, 2).equals_lower("cr") && 9165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 8) { 9175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegNo = CRRegs[IntVal]; 9185e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 9195e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 9205e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 9215e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 9225e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return true; 9235e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 9245e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 9255e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser:: 9265e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich WeigandParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) { 9275e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand const AsmToken &Tok = Parser.getTok(); 9285e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand StartLoc = Tok.getLoc(); 9295e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand EndLoc = Tok.getEndLoc(); 9305e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegNo = 0; 9315e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand int64_t IntVal; 9325e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 9335e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (!MatchRegisterName(Tok, RegNo, IntVal)) { 9345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); // Eat identifier token. 9355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 9365e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 9375e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 9385e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(StartLoc, "invalid register name"); 9395e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 9405e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 941746f7cafb2d1362de62024a6e62664c3eb3999d2NAKAMURA Takumi/// Extract \code @l/@ha \endcode modifier from expression. Recursively scan 942d2849572463da994c685b3bd7a60d5a7566c01e3Ulrich Weigand/// the expression and check for VK_PPC_LO/HI/HA 943027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand/// symbol variants. If all symbols with modifier use the same 944027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand/// variant, return the corresponding PPCMCExpr::VariantKind, 945027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand/// and a modified expression using the default symbol variant. 946027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand/// Otherwise, return NULL. 947027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigandconst MCExpr *PPCAsmParser:: 948027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich WeigandExtractModifierFromExpr(const MCExpr *E, 949027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand PPCMCExpr::VariantKind &Variant) { 950027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand MCContext &Context = getParser().getContext(); 951027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand Variant = PPCMCExpr::VK_PPC_None; 952027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 953027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand switch (E->getKind()) { 954027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand case MCExpr::Target: 955027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand case MCExpr::Constant: 956027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return 0; 957027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 958027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand case MCExpr::SymbolRef: { 959027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 960027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 961027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand switch (SRE->getKind()) { 96292cfa61c50d01307d658753f8d47f4e8555a6fa9Ulrich Weigand case MCSymbolRefExpr::VK_PPC_LO: 96392cfa61c50d01307d658753f8d47f4e8555a6fa9Ulrich Weigand Variant = PPCMCExpr::VK_PPC_LO; 964027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand break; 965d2849572463da994c685b3bd7a60d5a7566c01e3Ulrich Weigand case MCSymbolRefExpr::VK_PPC_HI: 966d2849572463da994c685b3bd7a60d5a7566c01e3Ulrich Weigand Variant = PPCMCExpr::VK_PPC_HI; 967d2849572463da994c685b3bd7a60d5a7566c01e3Ulrich Weigand break; 96892cfa61c50d01307d658753f8d47f4e8555a6fa9Ulrich Weigand case MCSymbolRefExpr::VK_PPC_HA: 96992cfa61c50d01307d658753f8d47f4e8555a6fa9Ulrich Weigand Variant = PPCMCExpr::VK_PPC_HA; 970027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand break; 971f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand case MCSymbolRefExpr::VK_PPC_HIGHER: 972f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand Variant = PPCMCExpr::VK_PPC_HIGHER; 973f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand break; 974f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand case MCSymbolRefExpr::VK_PPC_HIGHERA: 975f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand Variant = PPCMCExpr::VK_PPC_HIGHERA; 976f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand break; 977f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand case MCSymbolRefExpr::VK_PPC_HIGHEST: 978f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand Variant = PPCMCExpr::VK_PPC_HIGHEST; 979f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand break; 980f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand case MCSymbolRefExpr::VK_PPC_HIGHESTA: 981f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand Variant = PPCMCExpr::VK_PPC_HIGHESTA; 982f7c1ee79fe90353fcd3f545f9d45a01a837bbf4bUlrich Weigand break; 983027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand default: 984027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return 0; 985027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand } 986027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 987027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return MCSymbolRefExpr::Create(&SRE->getSymbol(), Context); 988027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand } 989027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 990027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand case MCExpr::Unary: { 991027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCUnaryExpr *UE = cast<MCUnaryExpr>(E); 992027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCExpr *Sub = ExtractModifierFromExpr(UE->getSubExpr(), Variant); 993027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (!Sub) 994027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return 0; 995027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return MCUnaryExpr::Create(UE->getOpcode(), Sub, Context); 996027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand } 997027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 998027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand case MCExpr::Binary: { 999027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 1000027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand PPCMCExpr::VariantKind LHSVariant, RHSVariant; 1001027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCExpr *LHS = ExtractModifierFromExpr(BE->getLHS(), LHSVariant); 1002027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCExpr *RHS = ExtractModifierFromExpr(BE->getRHS(), RHSVariant); 1003027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 1004027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (!LHS && !RHS) 1005027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return 0; 1006027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 1007027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (!LHS) LHS = BE->getLHS(); 1008027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (!RHS) RHS = BE->getRHS(); 1009027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 1010027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (LHSVariant == PPCMCExpr::VK_PPC_None) 1011027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand Variant = RHSVariant; 1012027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand else if (RHSVariant == PPCMCExpr::VK_PPC_None) 1013027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand Variant = LHSVariant; 1014027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand else if (LHSVariant == RHSVariant) 1015027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand Variant = LHSVariant; 1016027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand else 1017027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return 0; 1018027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 1019027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, Context); 1020027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand } 1021027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand } 1022027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 1023027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand llvm_unreachable("Invalid expression kind!"); 1024027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand} 1025027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 10267a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand/// Find all VK_TLSGD/VK_TLSLD symbol references in expression and replace 10277a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand/// them by VK_PPC_TLSGD/VK_PPC_TLSLD. This is necessary to avoid having 10287a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand/// _GLOBAL_OFFSET_TABLE_ created via ELFObjectWriter::RelocNeedsGOT. 10297a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand/// FIXME: This is a hack. 10307a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigandconst MCExpr *PPCAsmParser:: 10317a34599db017a5486cf7cd11eb124984acec8286Ulrich WeigandFixupVariantKind(const MCExpr *E) { 10327a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand MCContext &Context = getParser().getContext(); 10337a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 10347a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand switch (E->getKind()) { 10357a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand case MCExpr::Target: 10367a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand case MCExpr::Constant: 10377a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand return E; 10387a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 10397a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand case MCExpr::SymbolRef: { 10407a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 10417a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None; 10427a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 10437a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand switch (SRE->getKind()) { 10447a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand case MCSymbolRefExpr::VK_TLSGD: 10457a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand Variant = MCSymbolRefExpr::VK_PPC_TLSGD; 10467a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand break; 10477a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand case MCSymbolRefExpr::VK_TLSLD: 10487a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand Variant = MCSymbolRefExpr::VK_PPC_TLSLD; 10497a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand break; 10507a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand default: 10517a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand return E; 10527a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand } 10537a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand return MCSymbolRefExpr::Create(&SRE->getSymbol(), Variant, Context); 10547a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand } 10557a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 10567a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand case MCExpr::Unary: { 10577a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand const MCUnaryExpr *UE = cast<MCUnaryExpr>(E); 10587a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand const MCExpr *Sub = FixupVariantKind(UE->getSubExpr()); 10597a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand if (Sub == UE->getSubExpr()) 10607a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand return E; 10617a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand return MCUnaryExpr::Create(UE->getOpcode(), Sub, Context); 10627a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand } 10637a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 10647a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand case MCExpr::Binary: { 10657a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 10667a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand const MCExpr *LHS = FixupVariantKind(BE->getLHS()); 10677a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand const MCExpr *RHS = FixupVariantKind(BE->getRHS()); 10687a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand if (LHS == BE->getLHS() && RHS == BE->getRHS()) 10697a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand return E; 10707a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, Context); 10717a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand } 10727a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand } 10737a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 10747a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand llvm_unreachable("Invalid expression kind!"); 10757a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand} 10767a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 1077027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand/// Parse an expression. This differs from the default "parseExpression" 1078746f7cafb2d1362de62024a6e62664c3eb3999d2NAKAMURA Takumi/// in that it handles complex \code @l/@ha \endcode modifiers. 1079027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigandbool PPCAsmParser:: 1080027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich WeigandParseExpression(const MCExpr *&EVal) { 1081027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (getParser().parseExpression(EVal)) 1082027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return true; 1083027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 10847a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand EVal = FixupVariantKind(EVal); 10857a34599db017a5486cf7cd11eb124984acec8286Ulrich Weigand 1086027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand PPCMCExpr::VariantKind Variant; 1087027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand const MCExpr *E = ExtractModifierFromExpr(EVal, Variant); 1088027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (E) 1089a68f58ab2bec6a024afae498e4082ddd8b01f178Ulrich Weigand EVal = PPCMCExpr::Create(Variant, E, false, getParser().getContext()); 1090027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 1091027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand return false; 1092027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand} 1093027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand 10945e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser:: 10955e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich WeigandParseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 10965e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc S = Parser.getTok().getLoc(); 10975e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 10985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand const MCExpr *EVal; 10995e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand PPCOperand *Op; 11005e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11015e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Attempt to parse the next token as an immediate 11025e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand switch (getLexer().getKind()) { 11035e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Special handling for register names. These are interpreted 11045e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // as immediates corresponding to the register number. 11055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Percent: 11065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); // Eat the '%'. 11075e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand unsigned RegNo; 11085e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand int64_t IntVal; 11095e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (!MatchRegisterName(Parser.getTok(), RegNo, IntVal)) { 11105e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); // Eat the identifier token. 11115e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op = PPCOperand::CreateImm(IntVal, S, E, isPPC64()); 11125e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Operands.push_back(Op); 11135e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 11145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 11155e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(S, "invalid register name"); 11165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // All other expressions 11185e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::LParen: 11195e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Plus: 11205e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Minus: 11215e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Integer: 11225e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Identifier: 11235e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Dot: 11245e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Dollar: 1125027e94479c9e69eb3c3c5536fa9990d0b96e9510Ulrich Weigand if (!ParseExpression(EVal)) 11265e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 11275e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand /* fall through */ 11285e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand default: 11295e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(S, "unknown operand"); 11305e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 11315e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11325e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Push the parsed operand into the list of operands 113323a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Op = PPCOperand::CreateFromMCExpr(EVal, S, E, isPPC64()); 11345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Operands.push_back(Op); 11355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 113625b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand // Check whether this is a TLS call expression 113725b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand bool TLSCall = false; 113825b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(EVal)) 113925b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand TLSCall = Ref->getSymbol().getName() == "__tls_get_addr"; 114025b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand 114125b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand if (TLSCall && getLexer().is(AsmToken::LParen)) { 114225b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand const MCExpr *TLSSym; 114325b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand 114425b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand Parser.Lex(); // Eat the '('. 114525b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand S = Parser.getTok().getLoc(); 114625b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand if (ParseExpression(TLSSym)) 114725b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand return Error(S, "invalid TLS call expression"); 114825b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand if (getLexer().isNot(AsmToken::RParen)) 114925b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand return Error(Parser.getTok().getLoc(), "missing ')'"); 115025b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand E = Parser.getTok().getLoc(); 115125b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand Parser.Lex(); // Eat the ')'. 115225b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand 115323a72c8f7e46618ff8dbdbba4e8c1a2c4e44e3dfUlrich Weigand Op = PPCOperand::CreateFromMCExpr(TLSSym, S, E, isPPC64()); 115425b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand Operands.push_back(Op); 115525b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand } 115625b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand 115725b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand // Otherwise, check for D-form memory operands 115825b9bbae69befa03cc48d4be73b741eff8e523bcUlrich Weigand if (!TLSCall && getLexer().is(AsmToken::LParen)) { 11595e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); // Eat the '('. 11605e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand S = Parser.getTok().getLoc(); 11615e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11625e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand int64_t IntVal; 11635e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand switch (getLexer().getKind()) { 11645e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Percent: 11655e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); // Eat the '%'. 11665e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand unsigned RegNo; 11675e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (MatchRegisterName(Parser.getTok(), RegNo, IntVal)) 11685e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(S, "invalid register name"); 11695e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); // Eat the identifier token. 11705e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 11715e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11725e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand case AsmToken::Integer: 11735e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getParser().parseAbsoluteExpression(IntVal) || 11745e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand IntVal < 0 || IntVal > 31) 11755e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(S, "invalid register number"); 11765e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 11775e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11785e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand default: 11795e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(S, "invalid memory operand"); 11805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 11815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getLexer().isNot(AsmToken::RParen)) 11835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(Parser.getTok().getLoc(), "missing ')'"); 11845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand E = Parser.getTok().getLoc(); 11855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); // Eat the ')'. 11865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Op = PPCOperand::CreateImm(IntVal, S, E, isPPC64()); 11885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Operands.push_back(Op); 11895e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 11905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11915e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 11925e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 11935e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 11945e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// Parse an instruction mnemonic followed by its operands. 11955e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser:: 11965e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich WeigandParseInstruction(ParseInstructionInfo &Info, StringRef Name, SMLoc NameLoc, 11975e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 11985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // The first operand is the token for the instruction name. 11992e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand // If the next character is a '+' or '-', we need to add it to the 12002e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand // instruction name, to match what TableGen is doing. 1201af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer std::string NewOpcode; 12022e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand if (getLexer().is(AsmToken::Plus)) { 12032e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand getLexer().Lex(); 1204af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer NewOpcode = Name; 1205af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer NewOpcode += '+'; 1206af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Name = NewOpcode; 12072e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand } 12082e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand if (getLexer().is(AsmToken::Minus)) { 12092e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand getLexer().Lex(); 1210af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer NewOpcode = Name; 1211af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer NewOpcode += '-'; 1212af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Name = NewOpcode; 12132e8bd8950345b0857130dd0f4068222a79c103f2Ulrich Weigand } 12145e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // If the instruction ends in a '.', we need to create a separate 12155e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // token for it, to match what TableGen is doing. 12165e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand size_t Dot = Name.find('.'); 12175e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand StringRef Mnemonic = Name.slice(0, Dot); 1218af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer if (!NewOpcode.empty()) // Underlying memory for Name is volatile. 1219af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Operands.push_back( 1220af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer PPCOperand::CreateTokenWithStringCopy(Mnemonic, NameLoc, isPPC64())); 1221af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer else 1222af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Operands.push_back(PPCOperand::CreateToken(Mnemonic, NameLoc, isPPC64())); 12235e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (Dot != StringRef::npos) { 12245e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand SMLoc DotLoc = SMLoc::getFromPointer(NameLoc.getPointer() + Dot); 12255e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand StringRef DotStr = Name.slice(Dot, StringRef::npos); 1226af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer if (!NewOpcode.empty()) // Underlying memory for Name is volatile. 1227af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Operands.push_back( 1228af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer PPCOperand::CreateTokenWithStringCopy(DotStr, DotLoc, isPPC64())); 1229af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer else 1230af00feb1a6af78fbb07c4deca6e9e30a49cdcd15Benjamin Kramer Operands.push_back(PPCOperand::CreateToken(DotStr, DotLoc, isPPC64())); 12315e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 12325e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12335e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // If there are no more operands then finish 12345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getLexer().is(AsmToken::EndOfStatement)) 12355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 12365e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12375e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Parse the first operand 12385e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (ParseOperand(Operands)) 12395e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return true; 12405e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12415e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand while (getLexer().isNot(AsmToken::EndOfStatement) && 12425e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand getLexer().is(AsmToken::Comma)) { 12435e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Consume the comma token 12445e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand getLexer().Lex(); 12455e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12465e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Parse the next operand 12475e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (ParseOperand(Operands)) 12485e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return true; 12495e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 12505e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12515e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 12525e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 12535e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12545e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// ParseDirective parses the PPC specific directives 12555e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser::ParseDirective(AsmToken DirectiveID) { 12565e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand StringRef IDVal = DirectiveID.getIdentifier(); 12575e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (IDVal == ".word") 1258ff16df71f50231c79c379a146dc55b4d6867cbd9Ulrich Weigand return ParseDirectiveWord(2, DirectiveID.getLoc()); 1259ff16df71f50231c79c379a146dc55b4d6867cbd9Ulrich Weigand if (IDVal == ".llong") 1260ff16df71f50231c79c379a146dc55b4d6867cbd9Ulrich Weigand return ParseDirectiveWord(8, DirectiveID.getLoc()); 12615e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (IDVal == ".tc") 12625e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return ParseDirectiveTC(isPPC64()? 8 : 4, DirectiveID.getLoc()); 1263b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand if (IDVal == ".machine") 1264b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand return ParseDirectiveMachine(DirectiveID.getLoc()); 12655e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return true; 12665e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 12675e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12685e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// ParseDirectiveWord 12695e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// ::= .word [ expression (, expression)* ] 12705e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) { 12715e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getLexer().isNot(AsmToken::EndOfStatement)) { 12725e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand for (;;) { 12735e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand const MCExpr *Value; 12745e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getParser().parseExpression(Value)) 12755e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return true; 12765e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12775e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand getParser().getStreamer().EmitValue(Value, Size); 12785e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12795e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getLexer().is(AsmToken::EndOfStatement)) 12805e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand break; 12815e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12825e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getLexer().isNot(AsmToken::Comma)) 12835e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(L, "unexpected token in directive"); 12845e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); 12855e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 12865e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand } 12875e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12885e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); 12895e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return false; 12905e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 12915e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 12925e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// ParseDirectiveTC 12935e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// ::= .tc [ symbol (, expression)* ] 12945e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandbool PPCAsmParser::ParseDirectiveTC(unsigned Size, SMLoc L) { 12955e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Skip TC symbol, which is only used with XCOFF. 12965e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand while (getLexer().isNot(AsmToken::EndOfStatement) 12975e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand && getLexer().isNot(AsmToken::Comma)) 12985e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); 12995e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand if (getLexer().isNot(AsmToken::Comma)) 13005e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return Error(L, "unexpected token in directive"); 13015e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand Parser.Lex(); 13025e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 13035e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Align to word size. 13045e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand getParser().getStreamer().EmitValueToAlignment(Size); 13055e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 13065e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand // Emit expressions. 13075e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand return ParseDirectiveWord(Size, L); 13085e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 13095e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 1310b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand/// ParseDirectiveMachine 1311b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand/// ::= .machine [ cpu | "push" | "pop" ] 1312b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigandbool PPCAsmParser::ParseDirectiveMachine(SMLoc L) { 1313b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand if (getLexer().isNot(AsmToken::Identifier) && 1314b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand getLexer().isNot(AsmToken::String)) 1315b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand return Error(L, "unexpected token in directive"); 1316b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand 1317b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand StringRef CPU = Parser.getTok().getIdentifier(); 1318b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand Parser.Lex(); 1319b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand 1320b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand // FIXME: Right now, the parser always allows any available 1321b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand // instruction, so the .machine directive is not useful. 1322b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand // Implement ".machine any" (by doing nothing) for the benefit 1323b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand // of existing assembler code. Likewise, we can then implement 1324b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand // ".machine push" and ".machine pop" as no-op. 1325b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand if (CPU != "any" && CPU != "push" && CPU != "pop") 1326b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand return Error(L, "unrecognized machine type"); 1327b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand 1328b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand if (getLexer().isNot(AsmToken::EndOfStatement)) 1329b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand return Error(L, "unexpected token in directive"); 1330b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand 1331b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand return false; 1332b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand} 1333b2713e018e1c99bb9a65d2d2e63dc7e3e2222c57Ulrich Weigand 13345e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand/// Force static initialization. 13355e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigandextern "C" void LLVMInitializePowerPCAsmParser() { 13365e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegisterMCAsmParser<PPCAsmParser> A(ThePPC32Target); 13375e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand RegisterMCAsmParser<PPCAsmParser> B(ThePPC64Target); 1338f38cc38fa647d4e72c053c39bbe0cdec1342535fBill Schmidt RegisterMCAsmParser<PPCAsmParser> C(ThePPC64LETarget); 13395e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand} 13405e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand 13415e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#define GET_REGISTER_MATCHER 13425e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#define GET_MATCHER_IMPLEMENTATION 13435e220753ff81ac5cbee874e7c00c76c7fbe0d20aUlrich Weigand#include "PPCGenAsmMatcher.inc" 13449e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand 13459e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand// Define this matcher function after the auto-generated include so we 13469e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand// have the match class enum definitions. 13479e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigandunsigned PPCAsmParser::validateTargetOperandClass(MCParsedAsmOperand *AsmOp, 13489e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand unsigned Kind) { 13499e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand // If the kind is a token for a literal immediate, check if our asm 13509e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand // operand matches. This is for InstAliases which have a fixed-value 13519e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand // immediate in the syntax. 13529e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand int64_t ImmVal; 13539e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand switch (Kind) { 13549e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand case MCK_0: ImmVal = 0; break; 13559e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand case MCK_1: ImmVal = 1; break; 13569e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand default: return Match_InvalidOperand; 13579e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand } 13589e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand 13599e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand PPCOperand *Op = static_cast<PPCOperand*>(AsmOp); 13609e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand if (Op->isImm() && Op->getImm() == ImmVal) 13619e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand return Match_Success; 13629e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand 13639e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand return Match_InvalidOperand; 13649e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand} 13659e5bbeab1f6f79375c24bfab87c28f5f4c5afea1Ulrich Weigand 1366