1 //===-- PPCAsmParser.cpp - Parse PowerPC asm to MCInst instructions -------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "MCTargetDesc/PPCMCExpr.h" 10 #include "MCTargetDesc/PPCMCTargetDesc.h" 11 #include "PPCTargetStreamer.h" 12 #include "TargetInfo/PowerPCTargetInfo.h" 13 #include "llvm/ADT/STLExtras.h" 14 #include "llvm/ADT/StringSwitch.h" 15 #include "llvm/ADT/Twine.h" 16 #include "llvm/MC/MCContext.h" 17 #include "llvm/MC/MCExpr.h" 18 #include "llvm/MC/MCInst.h" 19 #include "llvm/MC/MCInstrInfo.h" 20 #include "llvm/MC/MCParser/MCAsmLexer.h" 21 #include "llvm/MC/MCParser/MCAsmParser.h" 22 #include "llvm/MC/MCParser/MCParsedAsmOperand.h" 23 #include "llvm/MC/MCParser/MCTargetAsmParser.h" 24 #include "llvm/MC/MCStreamer.h" 25 #include "llvm/MC/MCSubtargetInfo.h" 26 #include "llvm/MC/MCSymbolELF.h" 27 #include "llvm/Support/SourceMgr.h" 28 #include "llvm/Support/TargetRegistry.h" 29 #include "llvm/Support/raw_ostream.h" 30 31 using namespace llvm; 32 33 DEFINE_PPC_REGCLASSES; 34 35 // Evaluate an expression containing condition register 36 // or condition register field symbols. Returns positive 37 // value on success, or -1 on error. 38 static int64_t 39 EvaluateCRExpr(const MCExpr *E) { 40 switch (E->getKind()) { 41 case MCExpr::Target: 42 return -1; 43 44 case MCExpr::Constant: { 45 int64_t Res = cast<MCConstantExpr>(E)->getValue(); 46 return Res < 0 ? -1 : Res; 47 } 48 49 case MCExpr::SymbolRef: { 50 const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 51 StringRef Name = SRE->getSymbol().getName(); 52 53 if (Name == "lt") return 0; 54 if (Name == "gt") return 1; 55 if (Name == "eq") return 2; 56 if (Name == "so") return 3; 57 if (Name == "un") return 3; 58 59 if (Name == "cr0") return 0; 60 if (Name == "cr1") return 1; 61 if (Name == "cr2") return 2; 62 if (Name == "cr3") return 3; 63 if (Name == "cr4") return 4; 64 if (Name == "cr5") return 5; 65 if (Name == "cr6") return 6; 66 if (Name == "cr7") return 7; 67 68 return -1; 69 } 70 71 case MCExpr::Unary: 72 return -1; 73 74 case MCExpr::Binary: { 75 const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 76 int64_t LHSVal = EvaluateCRExpr(BE->getLHS()); 77 int64_t RHSVal = EvaluateCRExpr(BE->getRHS()); 78 int64_t Res; 79 80 if (LHSVal < 0 || RHSVal < 0) 81 return -1; 82 83 switch (BE->getOpcode()) { 84 default: return -1; 85 case MCBinaryExpr::Add: Res = LHSVal + RHSVal; break; 86 case MCBinaryExpr::Mul: Res = LHSVal * RHSVal; break; 87 } 88 89 return Res < 0 ? -1 : Res; 90 } 91 } 92 93 llvm_unreachable("Invalid expression kind!"); 94 } 95 96 namespace { 97 98 struct PPCOperand; 99 100 class PPCAsmParser : public MCTargetAsmParser { 101 bool IsPPC64; 102 bool IsDarwin; 103 104 void Warning(SMLoc L, const Twine &Msg) { getParser().Warning(L, Msg); } 105 106 bool isPPC64() const { return IsPPC64; } 107 bool isDarwin() const { return IsDarwin; } 108 109 bool MatchRegisterName(unsigned &RegNo, int64_t &IntVal); 110 111 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override; 112 OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc, 113 SMLoc &EndLoc) override; 114 115 const MCExpr *ExtractModifierFromExpr(const MCExpr *E, 116 PPCMCExpr::VariantKind &Variant); 117 const MCExpr *FixupVariantKind(const MCExpr *E); 118 bool ParseExpression(const MCExpr *&EVal); 119 bool ParseDarwinExpression(const MCExpr *&EVal); 120 121 bool ParseOperand(OperandVector &Operands); 122 123 bool ParseDirectiveWord(unsigned Size, AsmToken ID); 124 bool ParseDirectiveTC(unsigned Size, AsmToken ID); 125 bool ParseDirectiveMachine(SMLoc L); 126 bool ParseDarwinDirectiveMachine(SMLoc L); 127 bool ParseDirectiveAbiVersion(SMLoc L); 128 bool ParseDirectiveLocalEntry(SMLoc L); 129 130 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, 131 OperandVector &Operands, MCStreamer &Out, 132 uint64_t &ErrorInfo, 133 bool MatchingInlineAsm) override; 134 135 void ProcessInstruction(MCInst &Inst, const OperandVector &Ops); 136 137 /// @name Auto-generated Match Functions 138 /// { 139 140 #define GET_ASSEMBLER_HEADER 141 #include "PPCGenAsmMatcher.inc" 142 143 /// } 144 145 146 public: 147 PPCAsmParser(const MCSubtargetInfo &STI, MCAsmParser &, 148 const MCInstrInfo &MII, const MCTargetOptions &Options) 149 : MCTargetAsmParser(Options, STI, MII) { 150 // Check for 64-bit vs. 32-bit pointer mode. 151 const Triple &TheTriple = STI.getTargetTriple(); 152 IsPPC64 = TheTriple.isPPC64(); 153 IsDarwin = TheTriple.isMacOSX(); 154 // Initialize the set of available features. 155 setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits())); 156 } 157 158 bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name, 159 SMLoc NameLoc, OperandVector &Operands) override; 160 161 bool ParseDirective(AsmToken DirectiveID) override; 162 163 unsigned validateTargetOperandClass(MCParsedAsmOperand &Op, 164 unsigned Kind) override; 165 166 const MCExpr *applyModifierToExpr(const MCExpr *E, 167 MCSymbolRefExpr::VariantKind, 168 MCContext &Ctx) override; 169 }; 170 171 /// PPCOperand - Instances of this class represent a parsed PowerPC machine 172 /// instruction. 173 struct PPCOperand : public MCParsedAsmOperand { 174 enum KindTy { 175 Token, 176 Immediate, 177 ContextImmediate, 178 Expression, 179 TLSRegister 180 } Kind; 181 182 SMLoc StartLoc, EndLoc; 183 bool IsPPC64; 184 185 struct TokOp { 186 const char *Data; 187 unsigned Length; 188 }; 189 190 struct ImmOp { 191 int64_t Val; 192 }; 193 194 struct ExprOp { 195 const MCExpr *Val; 196 int64_t CRVal; // Cached result of EvaluateCRExpr(Val) 197 }; 198 199 struct TLSRegOp { 200 const MCSymbolRefExpr *Sym; 201 }; 202 203 union { 204 struct TokOp Tok; 205 struct ImmOp Imm; 206 struct ExprOp Expr; 207 struct TLSRegOp TLSReg; 208 }; 209 210 PPCOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {} 211 public: 212 PPCOperand(const PPCOperand &o) : MCParsedAsmOperand() { 213 Kind = o.Kind; 214 StartLoc = o.StartLoc; 215 EndLoc = o.EndLoc; 216 IsPPC64 = o.IsPPC64; 217 switch (Kind) { 218 case Token: 219 Tok = o.Tok; 220 break; 221 case Immediate: 222 case ContextImmediate: 223 Imm = o.Imm; 224 break; 225 case Expression: 226 Expr = o.Expr; 227 break; 228 case TLSRegister: 229 TLSReg = o.TLSReg; 230 break; 231 } 232 } 233 234 // Disable use of sized deallocation due to overallocation of PPCOperand 235 // objects in CreateTokenWithStringCopy. 236 void operator delete(void *p) { ::operator delete(p); } 237 238 /// getStartLoc - Get the location of the first token of this operand. 239 SMLoc getStartLoc() const override { return StartLoc; } 240 241 /// getEndLoc - Get the location of the last token of this operand. 242 SMLoc getEndLoc() const override { return EndLoc; } 243 244 /// getLocRange - Get the range between the first and last token of this 245 /// operand. 246 SMRange getLocRange() const { return SMRange(StartLoc, EndLoc); } 247 248 /// isPPC64 - True if this operand is for an instruction in 64-bit mode. 249 bool isPPC64() const { return IsPPC64; } 250 251 int64_t getImm() const { 252 assert(Kind == Immediate && "Invalid access!"); 253 return Imm.Val; 254 } 255 int64_t getImmS16Context() const { 256 assert((Kind == Immediate || Kind == ContextImmediate) && 257 "Invalid access!"); 258 if (Kind == Immediate) 259 return Imm.Val; 260 return static_cast<int16_t>(Imm.Val); 261 } 262 int64_t getImmU16Context() const { 263 assert((Kind == Immediate || Kind == ContextImmediate) && 264 "Invalid access!"); 265 return Imm.Val; 266 } 267 268 const MCExpr *getExpr() const { 269 assert(Kind == Expression && "Invalid access!"); 270 return Expr.Val; 271 } 272 273 int64_t getExprCRVal() const { 274 assert(Kind == Expression && "Invalid access!"); 275 return Expr.CRVal; 276 } 277 278 const MCExpr *getTLSReg() const { 279 assert(Kind == TLSRegister && "Invalid access!"); 280 return TLSReg.Sym; 281 } 282 283 unsigned getReg() const override { 284 assert(isRegNumber() && "Invalid access!"); 285 return (unsigned) Imm.Val; 286 } 287 288 unsigned getVSReg() const { 289 assert(isVSRegNumber() && "Invalid access!"); 290 return (unsigned) Imm.Val; 291 } 292 293 unsigned getACCReg() const { 294 assert(isACCRegNumber() && "Invalid access!"); 295 return (unsigned) Imm.Val; 296 } 297 298 unsigned getVSRpEvenReg() const { 299 assert(isVSRpEvenRegNumber() && "Invalid access!"); 300 return (unsigned) Imm.Val >> 1; 301 } 302 303 unsigned getCCReg() const { 304 assert(isCCRegNumber() && "Invalid access!"); 305 return (unsigned) (Kind == Immediate ? Imm.Val : Expr.CRVal); 306 } 307 308 unsigned getCRBit() const { 309 assert(isCRBitNumber() && "Invalid access!"); 310 return (unsigned) (Kind == Immediate ? Imm.Val : Expr.CRVal); 311 } 312 313 unsigned getCRBitMask() const { 314 assert(isCRBitMask() && "Invalid access!"); 315 return 7 - countTrailingZeros<uint64_t>(Imm.Val); 316 } 317 318 bool isToken() const override { return Kind == Token; } 319 bool isImm() const override { 320 return Kind == Immediate || Kind == Expression; 321 } 322 bool isU1Imm() const { return Kind == Immediate && isUInt<1>(getImm()); } 323 bool isU2Imm() const { return Kind == Immediate && isUInt<2>(getImm()); } 324 bool isU3Imm() const { return Kind == Immediate && isUInt<3>(getImm()); } 325 bool isU4Imm() const { return Kind == Immediate && isUInt<4>(getImm()); } 326 bool isU5Imm() const { return Kind == Immediate && isUInt<5>(getImm()); } 327 bool isS5Imm() const { return Kind == Immediate && isInt<5>(getImm()); } 328 bool isU6Imm() const { return Kind == Immediate && isUInt<6>(getImm()); } 329 bool isU6ImmX2() const { return Kind == Immediate && 330 isUInt<6>(getImm()) && 331 (getImm() & 1) == 0; } 332 bool isU7Imm() const { return Kind == Immediate && isUInt<7>(getImm()); } 333 bool isU7ImmX4() const { return Kind == Immediate && 334 isUInt<7>(getImm()) && 335 (getImm() & 3) == 0; } 336 bool isU8Imm() const { return Kind == Immediate && isUInt<8>(getImm()); } 337 bool isU8ImmX8() const { return Kind == Immediate && 338 isUInt<8>(getImm()) && 339 (getImm() & 7) == 0; } 340 341 bool isU10Imm() const { return Kind == Immediate && isUInt<10>(getImm()); } 342 bool isU12Imm() const { return Kind == Immediate && isUInt<12>(getImm()); } 343 bool isU16Imm() const { 344 switch (Kind) { 345 case Expression: 346 return true; 347 case Immediate: 348 case ContextImmediate: 349 return isUInt<16>(getImmU16Context()); 350 default: 351 return false; 352 } 353 } 354 bool isS16Imm() const { 355 switch (Kind) { 356 case Expression: 357 return true; 358 case Immediate: 359 case ContextImmediate: 360 return isInt<16>(getImmS16Context()); 361 default: 362 return false; 363 } 364 } 365 bool isS16ImmX4() const { return Kind == Expression || 366 (Kind == Immediate && isInt<16>(getImm()) && 367 (getImm() & 3) == 0); } 368 bool isS16ImmX16() const { return Kind == Expression || 369 (Kind == Immediate && isInt<16>(getImm()) && 370 (getImm() & 15) == 0); } 371 bool isS34ImmX16() const { 372 return Kind == Expression || 373 (Kind == Immediate && isInt<34>(getImm()) && (getImm() & 15) == 0); 374 } 375 bool isS34Imm() const { 376 // Once the PC-Rel ABI is finalized, evaluate whether a 34-bit 377 // ContextImmediate is needed. 378 return Kind == Expression || (Kind == Immediate && isInt<34>(getImm())); 379 } 380 381 bool isS17Imm() const { 382 switch (Kind) { 383 case Expression: 384 return true; 385 case Immediate: 386 case ContextImmediate: 387 return isInt<17>(getImmS16Context()); 388 default: 389 return false; 390 } 391 } 392 bool isTLSReg() const { return Kind == TLSRegister; } 393 bool isDirectBr() const { 394 if (Kind == Expression) 395 return true; 396 if (Kind != Immediate) 397 return false; 398 // Operand must be 64-bit aligned, signed 27-bit immediate. 399 if ((getImm() & 3) != 0) 400 return false; 401 if (isInt<26>(getImm())) 402 return true; 403 if (!IsPPC64) { 404 // In 32-bit mode, large 32-bit quantities wrap around. 405 if (isUInt<32>(getImm()) && isInt<26>(static_cast<int32_t>(getImm()))) 406 return true; 407 } 408 return false; 409 } 410 bool isCondBr() const { return Kind == Expression || 411 (Kind == Immediate && isInt<16>(getImm()) && 412 (getImm() & 3) == 0); } 413 bool isImmZero() const { return Kind == Immediate && getImm() == 0; } 414 bool isRegNumber() const { return Kind == Immediate && isUInt<5>(getImm()); } 415 bool isACCRegNumber() const { 416 return Kind == Immediate && isUInt<3>(getImm()); 417 } 418 bool isVSRpEvenRegNumber() const { 419 return Kind == Immediate && isUInt<6>(getImm()) && ((getImm() & 1) == 0); 420 } 421 bool isVSRegNumber() const { 422 return Kind == Immediate && isUInt<6>(getImm()); 423 } 424 bool isCCRegNumber() const { return (Kind == Expression 425 && isUInt<3>(getExprCRVal())) || 426 (Kind == Immediate 427 && isUInt<3>(getImm())); } 428 bool isCRBitNumber() const { return (Kind == Expression 429 && isUInt<5>(getExprCRVal())) || 430 (Kind == Immediate 431 && isUInt<5>(getImm())); } 432 bool isCRBitMask() const { return Kind == Immediate && isUInt<8>(getImm()) && 433 isPowerOf2_32(getImm()); } 434 bool isATBitsAsHint() const { return false; } 435 bool isMem() const override { return false; } 436 bool isReg() const override { return false; } 437 438 void addRegOperands(MCInst &Inst, unsigned N) const { 439 llvm_unreachable("addRegOperands"); 440 } 441 442 void addRegGPRCOperands(MCInst &Inst, unsigned N) const { 443 assert(N == 1 && "Invalid number of operands!"); 444 Inst.addOperand(MCOperand::createReg(RRegs[getReg()])); 445 } 446 447 void addRegGPRCNoR0Operands(MCInst &Inst, unsigned N) const { 448 assert(N == 1 && "Invalid number of operands!"); 449 Inst.addOperand(MCOperand::createReg(RRegsNoR0[getReg()])); 450 } 451 452 void addRegG8RCOperands(MCInst &Inst, unsigned N) const { 453 assert(N == 1 && "Invalid number of operands!"); 454 Inst.addOperand(MCOperand::createReg(XRegs[getReg()])); 455 } 456 457 void addRegG8RCNoX0Operands(MCInst &Inst, unsigned N) const { 458 assert(N == 1 && "Invalid number of operands!"); 459 Inst.addOperand(MCOperand::createReg(XRegsNoX0[getReg()])); 460 } 461 462 void addRegGxRCOperands(MCInst &Inst, unsigned N) const { 463 if (isPPC64()) 464 addRegG8RCOperands(Inst, N); 465 else 466 addRegGPRCOperands(Inst, N); 467 } 468 469 void addRegGxRCNoR0Operands(MCInst &Inst, unsigned N) const { 470 if (isPPC64()) 471 addRegG8RCNoX0Operands(Inst, N); 472 else 473 addRegGPRCNoR0Operands(Inst, N); 474 } 475 476 void addRegF4RCOperands(MCInst &Inst, unsigned N) const { 477 assert(N == 1 && "Invalid number of operands!"); 478 Inst.addOperand(MCOperand::createReg(FRegs[getReg()])); 479 } 480 481 void addRegF8RCOperands(MCInst &Inst, unsigned N) const { 482 assert(N == 1 && "Invalid number of operands!"); 483 Inst.addOperand(MCOperand::createReg(FRegs[getReg()])); 484 } 485 486 void addRegVFRCOperands(MCInst &Inst, unsigned N) const { 487 assert(N == 1 && "Invalid number of operands!"); 488 Inst.addOperand(MCOperand::createReg(VFRegs[getReg()])); 489 } 490 491 void addRegVRRCOperands(MCInst &Inst, unsigned N) const { 492 assert(N == 1 && "Invalid number of operands!"); 493 Inst.addOperand(MCOperand::createReg(VRegs[getReg()])); 494 } 495 496 void addRegVSRCOperands(MCInst &Inst, unsigned N) const { 497 assert(N == 1 && "Invalid number of operands!"); 498 Inst.addOperand(MCOperand::createReg(VSRegs[getVSReg()])); 499 } 500 501 void addRegVSFRCOperands(MCInst &Inst, unsigned N) const { 502 assert(N == 1 && "Invalid number of operands!"); 503 Inst.addOperand(MCOperand::createReg(VSFRegs[getVSReg()])); 504 } 505 506 void addRegVSSRCOperands(MCInst &Inst, unsigned N) const { 507 assert(N == 1 && "Invalid number of operands!"); 508 Inst.addOperand(MCOperand::createReg(VSSRegs[getVSReg()])); 509 } 510 511 void addRegSPE4RCOperands(MCInst &Inst, unsigned N) const { 512 assert(N == 1 && "Invalid number of operands!"); 513 Inst.addOperand(MCOperand::createReg(RRegs[getReg()])); 514 } 515 516 void addRegSPERCOperands(MCInst &Inst, unsigned N) const { 517 assert(N == 1 && "Invalid number of operands!"); 518 Inst.addOperand(MCOperand::createReg(SPERegs[getReg()])); 519 } 520 521 void addRegACCRCOperands(MCInst &Inst, unsigned N) const { 522 assert(N == 1 && "Invalid number of operands!"); 523 Inst.addOperand(MCOperand::createReg(ACCRegs[getACCReg()])); 524 } 525 526 void addRegVSRpRCOperands(MCInst &Inst, unsigned N) const { 527 assert(N == 1 && "Invalid number of operands!"); 528 Inst.addOperand(MCOperand::createReg(VSRpRegs[getVSRpEvenReg()])); 529 } 530 531 void addRegVSRpEvenRCOperands(MCInst &Inst, unsigned N) const { 532 assert(N == 1 && "Invalid number of operands!"); 533 Inst.addOperand(MCOperand::createReg(VSRpRegs[getVSRpEvenReg()])); 534 } 535 536 void addRegCRBITRCOperands(MCInst &Inst, unsigned N) const { 537 assert(N == 1 && "Invalid number of operands!"); 538 Inst.addOperand(MCOperand::createReg(CRBITRegs[getCRBit()])); 539 } 540 541 void addRegCRRCOperands(MCInst &Inst, unsigned N) const { 542 assert(N == 1 && "Invalid number of operands!"); 543 Inst.addOperand(MCOperand::createReg(CRRegs[getCCReg()])); 544 } 545 546 void addCRBitMaskOperands(MCInst &Inst, unsigned N) const { 547 assert(N == 1 && "Invalid number of operands!"); 548 Inst.addOperand(MCOperand::createReg(CRRegs[getCRBitMask()])); 549 } 550 551 void addImmOperands(MCInst &Inst, unsigned N) const { 552 assert(N == 1 && "Invalid number of operands!"); 553 if (Kind == Immediate) 554 Inst.addOperand(MCOperand::createImm(getImm())); 555 else 556 Inst.addOperand(MCOperand::createExpr(getExpr())); 557 } 558 559 void addS16ImmOperands(MCInst &Inst, unsigned N) const { 560 assert(N == 1 && "Invalid number of operands!"); 561 switch (Kind) { 562 case Immediate: 563 Inst.addOperand(MCOperand::createImm(getImm())); 564 break; 565 case ContextImmediate: 566 Inst.addOperand(MCOperand::createImm(getImmS16Context())); 567 break; 568 default: 569 Inst.addOperand(MCOperand::createExpr(getExpr())); 570 break; 571 } 572 } 573 574 void addU16ImmOperands(MCInst &Inst, unsigned N) const { 575 assert(N == 1 && "Invalid number of operands!"); 576 switch (Kind) { 577 case Immediate: 578 Inst.addOperand(MCOperand::createImm(getImm())); 579 break; 580 case ContextImmediate: 581 Inst.addOperand(MCOperand::createImm(getImmU16Context())); 582 break; 583 default: 584 Inst.addOperand(MCOperand::createExpr(getExpr())); 585 break; 586 } 587 } 588 589 void addBranchTargetOperands(MCInst &Inst, unsigned N) const { 590 assert(N == 1 && "Invalid number of operands!"); 591 if (Kind == Immediate) 592 Inst.addOperand(MCOperand::createImm(getImm() / 4)); 593 else 594 Inst.addOperand(MCOperand::createExpr(getExpr())); 595 } 596 597 void addTLSRegOperands(MCInst &Inst, unsigned N) const { 598 assert(N == 1 && "Invalid number of operands!"); 599 Inst.addOperand(MCOperand::createExpr(getTLSReg())); 600 } 601 602 StringRef getToken() const { 603 assert(Kind == Token && "Invalid access!"); 604 return StringRef(Tok.Data, Tok.Length); 605 } 606 607 void print(raw_ostream &OS) const override; 608 609 static std::unique_ptr<PPCOperand> CreateToken(StringRef Str, SMLoc S, 610 bool IsPPC64) { 611 auto Op = std::make_unique<PPCOperand>(Token); 612 Op->Tok.Data = Str.data(); 613 Op->Tok.Length = Str.size(); 614 Op->StartLoc = S; 615 Op->EndLoc = S; 616 Op->IsPPC64 = IsPPC64; 617 return Op; 618 } 619 620 static std::unique_ptr<PPCOperand> 621 CreateTokenWithStringCopy(StringRef Str, SMLoc S, bool IsPPC64) { 622 // Allocate extra memory for the string and copy it. 623 // FIXME: This is incorrect, Operands are owned by unique_ptr with a default 624 // deleter which will destroy them by simply using "delete", not correctly 625 // calling operator delete on this extra memory after calling the dtor 626 // explicitly. 627 void *Mem = ::operator new(sizeof(PPCOperand) + Str.size()); 628 std::unique_ptr<PPCOperand> Op(new (Mem) PPCOperand(Token)); 629 Op->Tok.Data = reinterpret_cast<const char *>(Op.get() + 1); 630 Op->Tok.Length = Str.size(); 631 std::memcpy(const_cast<char *>(Op->Tok.Data), Str.data(), Str.size()); 632 Op->StartLoc = S; 633 Op->EndLoc = S; 634 Op->IsPPC64 = IsPPC64; 635 return Op; 636 } 637 638 static std::unique_ptr<PPCOperand> CreateImm(int64_t Val, SMLoc S, SMLoc E, 639 bool IsPPC64) { 640 auto Op = std::make_unique<PPCOperand>(Immediate); 641 Op->Imm.Val = Val; 642 Op->StartLoc = S; 643 Op->EndLoc = E; 644 Op->IsPPC64 = IsPPC64; 645 return Op; 646 } 647 648 static std::unique_ptr<PPCOperand> CreateExpr(const MCExpr *Val, SMLoc S, 649 SMLoc E, bool IsPPC64) { 650 auto Op = std::make_unique<PPCOperand>(Expression); 651 Op->Expr.Val = Val; 652 Op->Expr.CRVal = EvaluateCRExpr(Val); 653 Op->StartLoc = S; 654 Op->EndLoc = E; 655 Op->IsPPC64 = IsPPC64; 656 return Op; 657 } 658 659 static std::unique_ptr<PPCOperand> 660 CreateTLSReg(const MCSymbolRefExpr *Sym, SMLoc S, SMLoc E, bool IsPPC64) { 661 auto Op = std::make_unique<PPCOperand>(TLSRegister); 662 Op->TLSReg.Sym = Sym; 663 Op->StartLoc = S; 664 Op->EndLoc = E; 665 Op->IsPPC64 = IsPPC64; 666 return Op; 667 } 668 669 static std::unique_ptr<PPCOperand> 670 CreateContextImm(int64_t Val, SMLoc S, SMLoc E, bool IsPPC64) { 671 auto Op = std::make_unique<PPCOperand>(ContextImmediate); 672 Op->Imm.Val = Val; 673 Op->StartLoc = S; 674 Op->EndLoc = E; 675 Op->IsPPC64 = IsPPC64; 676 return Op; 677 } 678 679 static std::unique_ptr<PPCOperand> 680 CreateFromMCExpr(const MCExpr *Val, SMLoc S, SMLoc E, bool IsPPC64) { 681 if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Val)) 682 return CreateImm(CE->getValue(), S, E, IsPPC64); 683 684 if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(Val)) 685 if (SRE->getKind() == MCSymbolRefExpr::VK_PPC_TLS || 686 SRE->getKind() == MCSymbolRefExpr::VK_PPC_TLS_PCREL) 687 return CreateTLSReg(SRE, S, E, IsPPC64); 688 689 if (const PPCMCExpr *TE = dyn_cast<PPCMCExpr>(Val)) { 690 int64_t Res; 691 if (TE->evaluateAsConstant(Res)) 692 return CreateContextImm(Res, S, E, IsPPC64); 693 } 694 695 return CreateExpr(Val, S, E, IsPPC64); 696 } 697 }; 698 699 } // end anonymous namespace. 700 701 void PPCOperand::print(raw_ostream &OS) const { 702 switch (Kind) { 703 case Token: 704 OS << "'" << getToken() << "'"; 705 break; 706 case Immediate: 707 case ContextImmediate: 708 OS << getImm(); 709 break; 710 case Expression: 711 OS << *getExpr(); 712 break; 713 case TLSRegister: 714 OS << *getTLSReg(); 715 break; 716 } 717 } 718 719 static void 720 addNegOperand(MCInst &Inst, MCOperand &Op, MCContext &Ctx) { 721 if (Op.isImm()) { 722 Inst.addOperand(MCOperand::createImm(-Op.getImm())); 723 return; 724 } 725 const MCExpr *Expr = Op.getExpr(); 726 if (const MCUnaryExpr *UnExpr = dyn_cast<MCUnaryExpr>(Expr)) { 727 if (UnExpr->getOpcode() == MCUnaryExpr::Minus) { 728 Inst.addOperand(MCOperand::createExpr(UnExpr->getSubExpr())); 729 return; 730 } 731 } else if (const MCBinaryExpr *BinExpr = dyn_cast<MCBinaryExpr>(Expr)) { 732 if (BinExpr->getOpcode() == MCBinaryExpr::Sub) { 733 const MCExpr *NE = MCBinaryExpr::createSub(BinExpr->getRHS(), 734 BinExpr->getLHS(), Ctx); 735 Inst.addOperand(MCOperand::createExpr(NE)); 736 return; 737 } 738 } 739 Inst.addOperand(MCOperand::createExpr(MCUnaryExpr::createMinus(Expr, Ctx))); 740 } 741 742 void PPCAsmParser::ProcessInstruction(MCInst &Inst, 743 const OperandVector &Operands) { 744 int Opcode = Inst.getOpcode(); 745 switch (Opcode) { 746 case PPC::DCBTx: 747 case PPC::DCBTT: 748 case PPC::DCBTSTx: 749 case PPC::DCBTSTT: { 750 MCInst TmpInst; 751 TmpInst.setOpcode((Opcode == PPC::DCBTx || Opcode == PPC::DCBTT) ? 752 PPC::DCBT : PPC::DCBTST); 753 TmpInst.addOperand(MCOperand::createImm( 754 (Opcode == PPC::DCBTx || Opcode == PPC::DCBTSTx) ? 0 : 16)); 755 TmpInst.addOperand(Inst.getOperand(0)); 756 TmpInst.addOperand(Inst.getOperand(1)); 757 Inst = TmpInst; 758 break; 759 } 760 case PPC::DCBTCT: 761 case PPC::DCBTDS: { 762 MCInst TmpInst; 763 TmpInst.setOpcode(PPC::DCBT); 764 TmpInst.addOperand(Inst.getOperand(2)); 765 TmpInst.addOperand(Inst.getOperand(0)); 766 TmpInst.addOperand(Inst.getOperand(1)); 767 Inst = TmpInst; 768 break; 769 } 770 case PPC::DCBTSTCT: 771 case PPC::DCBTSTDS: { 772 MCInst TmpInst; 773 TmpInst.setOpcode(PPC::DCBTST); 774 TmpInst.addOperand(Inst.getOperand(2)); 775 TmpInst.addOperand(Inst.getOperand(0)); 776 TmpInst.addOperand(Inst.getOperand(1)); 777 Inst = TmpInst; 778 break; 779 } 780 case PPC::DCBFx: 781 case PPC::DCBFL: 782 case PPC::DCBFLP: { 783 int L = 0; 784 if (Opcode == PPC::DCBFL) 785 L = 1; 786 else if (Opcode == PPC::DCBFLP) 787 L = 3; 788 789 MCInst TmpInst; 790 TmpInst.setOpcode(PPC::DCBF); 791 TmpInst.addOperand(MCOperand::createImm(L)); 792 TmpInst.addOperand(Inst.getOperand(0)); 793 TmpInst.addOperand(Inst.getOperand(1)); 794 Inst = TmpInst; 795 break; 796 } 797 case PPC::LAx: { 798 MCInst TmpInst; 799 TmpInst.setOpcode(PPC::LA); 800 TmpInst.addOperand(Inst.getOperand(0)); 801 TmpInst.addOperand(Inst.getOperand(2)); 802 TmpInst.addOperand(Inst.getOperand(1)); 803 Inst = TmpInst; 804 break; 805 } 806 case PPC::SUBI: { 807 MCInst TmpInst; 808 TmpInst.setOpcode(PPC::ADDI); 809 TmpInst.addOperand(Inst.getOperand(0)); 810 TmpInst.addOperand(Inst.getOperand(1)); 811 addNegOperand(TmpInst, Inst.getOperand(2), getContext()); 812 Inst = TmpInst; 813 break; 814 } 815 case PPC::SUBIS: { 816 MCInst TmpInst; 817 TmpInst.setOpcode(PPC::ADDIS); 818 TmpInst.addOperand(Inst.getOperand(0)); 819 TmpInst.addOperand(Inst.getOperand(1)); 820 addNegOperand(TmpInst, Inst.getOperand(2), getContext()); 821 Inst = TmpInst; 822 break; 823 } 824 case PPC::SUBIC: { 825 MCInst TmpInst; 826 TmpInst.setOpcode(PPC::ADDIC); 827 TmpInst.addOperand(Inst.getOperand(0)); 828 TmpInst.addOperand(Inst.getOperand(1)); 829 addNegOperand(TmpInst, Inst.getOperand(2), getContext()); 830 Inst = TmpInst; 831 break; 832 } 833 case PPC::SUBIC_rec: { 834 MCInst TmpInst; 835 TmpInst.setOpcode(PPC::ADDIC_rec); 836 TmpInst.addOperand(Inst.getOperand(0)); 837 TmpInst.addOperand(Inst.getOperand(1)); 838 addNegOperand(TmpInst, Inst.getOperand(2), getContext()); 839 Inst = TmpInst; 840 break; 841 } 842 case PPC::EXTLWI: 843 case PPC::EXTLWI_rec: { 844 MCInst TmpInst; 845 int64_t N = Inst.getOperand(2).getImm(); 846 int64_t B = Inst.getOperand(3).getImm(); 847 TmpInst.setOpcode(Opcode == PPC::EXTLWI ? PPC::RLWINM : PPC::RLWINM_rec); 848 TmpInst.addOperand(Inst.getOperand(0)); 849 TmpInst.addOperand(Inst.getOperand(1)); 850 TmpInst.addOperand(MCOperand::createImm(B)); 851 TmpInst.addOperand(MCOperand::createImm(0)); 852 TmpInst.addOperand(MCOperand::createImm(N - 1)); 853 Inst = TmpInst; 854 break; 855 } 856 case PPC::EXTRWI: 857 case PPC::EXTRWI_rec: { 858 MCInst TmpInst; 859 int64_t N = Inst.getOperand(2).getImm(); 860 int64_t B = Inst.getOperand(3).getImm(); 861 TmpInst.setOpcode(Opcode == PPC::EXTRWI ? PPC::RLWINM : PPC::RLWINM_rec); 862 TmpInst.addOperand(Inst.getOperand(0)); 863 TmpInst.addOperand(Inst.getOperand(1)); 864 TmpInst.addOperand(MCOperand::createImm(B + N)); 865 TmpInst.addOperand(MCOperand::createImm(32 - N)); 866 TmpInst.addOperand(MCOperand::createImm(31)); 867 Inst = TmpInst; 868 break; 869 } 870 case PPC::INSLWI: 871 case PPC::INSLWI_rec: { 872 MCInst TmpInst; 873 int64_t N = Inst.getOperand(2).getImm(); 874 int64_t B = Inst.getOperand(3).getImm(); 875 TmpInst.setOpcode(Opcode == PPC::INSLWI ? PPC::RLWIMI : PPC::RLWIMI_rec); 876 TmpInst.addOperand(Inst.getOperand(0)); 877 TmpInst.addOperand(Inst.getOperand(0)); 878 TmpInst.addOperand(Inst.getOperand(1)); 879 TmpInst.addOperand(MCOperand::createImm(32 - B)); 880 TmpInst.addOperand(MCOperand::createImm(B)); 881 TmpInst.addOperand(MCOperand::createImm((B + N) - 1)); 882 Inst = TmpInst; 883 break; 884 } 885 case PPC::INSRWI: 886 case PPC::INSRWI_rec: { 887 MCInst TmpInst; 888 int64_t N = Inst.getOperand(2).getImm(); 889 int64_t B = Inst.getOperand(3).getImm(); 890 TmpInst.setOpcode(Opcode == PPC::INSRWI ? PPC::RLWIMI : PPC::RLWIMI_rec); 891 TmpInst.addOperand(Inst.getOperand(0)); 892 TmpInst.addOperand(Inst.getOperand(0)); 893 TmpInst.addOperand(Inst.getOperand(1)); 894 TmpInst.addOperand(MCOperand::createImm(32 - (B + N))); 895 TmpInst.addOperand(MCOperand::createImm(B)); 896 TmpInst.addOperand(MCOperand::createImm((B + N) - 1)); 897 Inst = TmpInst; 898 break; 899 } 900 case PPC::ROTRWI: 901 case PPC::ROTRWI_rec: { 902 MCInst TmpInst; 903 int64_t N = Inst.getOperand(2).getImm(); 904 TmpInst.setOpcode(Opcode == PPC::ROTRWI ? PPC::RLWINM : PPC::RLWINM_rec); 905 TmpInst.addOperand(Inst.getOperand(0)); 906 TmpInst.addOperand(Inst.getOperand(1)); 907 TmpInst.addOperand(MCOperand::createImm(32 - N)); 908 TmpInst.addOperand(MCOperand::createImm(0)); 909 TmpInst.addOperand(MCOperand::createImm(31)); 910 Inst = TmpInst; 911 break; 912 } 913 case PPC::SLWI: 914 case PPC::SLWI_rec: { 915 MCInst TmpInst; 916 int64_t N = Inst.getOperand(2).getImm(); 917 TmpInst.setOpcode(Opcode == PPC::SLWI ? PPC::RLWINM : PPC::RLWINM_rec); 918 TmpInst.addOperand(Inst.getOperand(0)); 919 TmpInst.addOperand(Inst.getOperand(1)); 920 TmpInst.addOperand(MCOperand::createImm(N)); 921 TmpInst.addOperand(MCOperand::createImm(0)); 922 TmpInst.addOperand(MCOperand::createImm(31 - N)); 923 Inst = TmpInst; 924 break; 925 } 926 case PPC::SRWI: 927 case PPC::SRWI_rec: { 928 MCInst TmpInst; 929 int64_t N = Inst.getOperand(2).getImm(); 930 TmpInst.setOpcode(Opcode == PPC::SRWI ? PPC::RLWINM : PPC::RLWINM_rec); 931 TmpInst.addOperand(Inst.getOperand(0)); 932 TmpInst.addOperand(Inst.getOperand(1)); 933 TmpInst.addOperand(MCOperand::createImm(32 - N)); 934 TmpInst.addOperand(MCOperand::createImm(N)); 935 TmpInst.addOperand(MCOperand::createImm(31)); 936 Inst = TmpInst; 937 break; 938 } 939 case PPC::CLRRWI: 940 case PPC::CLRRWI_rec: { 941 MCInst TmpInst; 942 int64_t N = Inst.getOperand(2).getImm(); 943 TmpInst.setOpcode(Opcode == PPC::CLRRWI ? PPC::RLWINM : PPC::RLWINM_rec); 944 TmpInst.addOperand(Inst.getOperand(0)); 945 TmpInst.addOperand(Inst.getOperand(1)); 946 TmpInst.addOperand(MCOperand::createImm(0)); 947 TmpInst.addOperand(MCOperand::createImm(0)); 948 TmpInst.addOperand(MCOperand::createImm(31 - N)); 949 Inst = TmpInst; 950 break; 951 } 952 case PPC::CLRLSLWI: 953 case PPC::CLRLSLWI_rec: { 954 MCInst TmpInst; 955 int64_t B = Inst.getOperand(2).getImm(); 956 int64_t N = Inst.getOperand(3).getImm(); 957 TmpInst.setOpcode(Opcode == PPC::CLRLSLWI ? PPC::RLWINM : PPC::RLWINM_rec); 958 TmpInst.addOperand(Inst.getOperand(0)); 959 TmpInst.addOperand(Inst.getOperand(1)); 960 TmpInst.addOperand(MCOperand::createImm(N)); 961 TmpInst.addOperand(MCOperand::createImm(B - N)); 962 TmpInst.addOperand(MCOperand::createImm(31 - N)); 963 Inst = TmpInst; 964 break; 965 } 966 case PPC::EXTLDI: 967 case PPC::EXTLDI_rec: { 968 MCInst TmpInst; 969 int64_t N = Inst.getOperand(2).getImm(); 970 int64_t B = Inst.getOperand(3).getImm(); 971 TmpInst.setOpcode(Opcode == PPC::EXTLDI ? PPC::RLDICR : PPC::RLDICR_rec); 972 TmpInst.addOperand(Inst.getOperand(0)); 973 TmpInst.addOperand(Inst.getOperand(1)); 974 TmpInst.addOperand(MCOperand::createImm(B)); 975 TmpInst.addOperand(MCOperand::createImm(N - 1)); 976 Inst = TmpInst; 977 break; 978 } 979 case PPC::EXTRDI: 980 case PPC::EXTRDI_rec: { 981 MCInst TmpInst; 982 int64_t N = Inst.getOperand(2).getImm(); 983 int64_t B = Inst.getOperand(3).getImm(); 984 TmpInst.setOpcode(Opcode == PPC::EXTRDI ? PPC::RLDICL : PPC::RLDICL_rec); 985 TmpInst.addOperand(Inst.getOperand(0)); 986 TmpInst.addOperand(Inst.getOperand(1)); 987 TmpInst.addOperand(MCOperand::createImm(B + N)); 988 TmpInst.addOperand(MCOperand::createImm(64 - N)); 989 Inst = TmpInst; 990 break; 991 } 992 case PPC::INSRDI: 993 case PPC::INSRDI_rec: { 994 MCInst TmpInst; 995 int64_t N = Inst.getOperand(2).getImm(); 996 int64_t B = Inst.getOperand(3).getImm(); 997 TmpInst.setOpcode(Opcode == PPC::INSRDI ? PPC::RLDIMI : PPC::RLDIMI_rec); 998 TmpInst.addOperand(Inst.getOperand(0)); 999 TmpInst.addOperand(Inst.getOperand(0)); 1000 TmpInst.addOperand(Inst.getOperand(1)); 1001 TmpInst.addOperand(MCOperand::createImm(64 - (B + N))); 1002 TmpInst.addOperand(MCOperand::createImm(B)); 1003 Inst = TmpInst; 1004 break; 1005 } 1006 case PPC::ROTRDI: 1007 case PPC::ROTRDI_rec: { 1008 MCInst TmpInst; 1009 int64_t N = Inst.getOperand(2).getImm(); 1010 TmpInst.setOpcode(Opcode == PPC::ROTRDI ? PPC::RLDICL : PPC::RLDICL_rec); 1011 TmpInst.addOperand(Inst.getOperand(0)); 1012 TmpInst.addOperand(Inst.getOperand(1)); 1013 TmpInst.addOperand(MCOperand::createImm(64 - N)); 1014 TmpInst.addOperand(MCOperand::createImm(0)); 1015 Inst = TmpInst; 1016 break; 1017 } 1018 case PPC::SLDI: 1019 case PPC::SLDI_rec: { 1020 MCInst TmpInst; 1021 int64_t N = Inst.getOperand(2).getImm(); 1022 TmpInst.setOpcode(Opcode == PPC::SLDI ? PPC::RLDICR : PPC::RLDICR_rec); 1023 TmpInst.addOperand(Inst.getOperand(0)); 1024 TmpInst.addOperand(Inst.getOperand(1)); 1025 TmpInst.addOperand(MCOperand::createImm(N)); 1026 TmpInst.addOperand(MCOperand::createImm(63 - N)); 1027 Inst = TmpInst; 1028 break; 1029 } 1030 case PPC::SUBPCIS: { 1031 MCInst TmpInst; 1032 int64_t N = Inst.getOperand(1).getImm(); 1033 TmpInst.setOpcode(PPC::ADDPCIS); 1034 TmpInst.addOperand(Inst.getOperand(0)); 1035 TmpInst.addOperand(MCOperand::createImm(-N)); 1036 Inst = TmpInst; 1037 break; 1038 } 1039 case PPC::SRDI: 1040 case PPC::SRDI_rec: { 1041 MCInst TmpInst; 1042 int64_t N = Inst.getOperand(2).getImm(); 1043 TmpInst.setOpcode(Opcode == PPC::SRDI ? PPC::RLDICL : PPC::RLDICL_rec); 1044 TmpInst.addOperand(Inst.getOperand(0)); 1045 TmpInst.addOperand(Inst.getOperand(1)); 1046 TmpInst.addOperand(MCOperand::createImm(64 - N)); 1047 TmpInst.addOperand(MCOperand::createImm(N)); 1048 Inst = TmpInst; 1049 break; 1050 } 1051 case PPC::CLRRDI: 1052 case PPC::CLRRDI_rec: { 1053 MCInst TmpInst; 1054 int64_t N = Inst.getOperand(2).getImm(); 1055 TmpInst.setOpcode(Opcode == PPC::CLRRDI ? PPC::RLDICR : PPC::RLDICR_rec); 1056 TmpInst.addOperand(Inst.getOperand(0)); 1057 TmpInst.addOperand(Inst.getOperand(1)); 1058 TmpInst.addOperand(MCOperand::createImm(0)); 1059 TmpInst.addOperand(MCOperand::createImm(63 - N)); 1060 Inst = TmpInst; 1061 break; 1062 } 1063 case PPC::CLRLSLDI: 1064 case PPC::CLRLSLDI_rec: { 1065 MCInst TmpInst; 1066 int64_t B = Inst.getOperand(2).getImm(); 1067 int64_t N = Inst.getOperand(3).getImm(); 1068 TmpInst.setOpcode(Opcode == PPC::CLRLSLDI ? PPC::RLDIC : PPC::RLDIC_rec); 1069 TmpInst.addOperand(Inst.getOperand(0)); 1070 TmpInst.addOperand(Inst.getOperand(1)); 1071 TmpInst.addOperand(MCOperand::createImm(N)); 1072 TmpInst.addOperand(MCOperand::createImm(B - N)); 1073 Inst = TmpInst; 1074 break; 1075 } 1076 case PPC::RLWINMbm: 1077 case PPC::RLWINMbm_rec: { 1078 unsigned MB, ME; 1079 int64_t BM = Inst.getOperand(3).getImm(); 1080 if (!isRunOfOnes(BM, MB, ME)) 1081 break; 1082 1083 MCInst TmpInst; 1084 TmpInst.setOpcode(Opcode == PPC::RLWINMbm ? PPC::RLWINM : PPC::RLWINM_rec); 1085 TmpInst.addOperand(Inst.getOperand(0)); 1086 TmpInst.addOperand(Inst.getOperand(1)); 1087 TmpInst.addOperand(Inst.getOperand(2)); 1088 TmpInst.addOperand(MCOperand::createImm(MB)); 1089 TmpInst.addOperand(MCOperand::createImm(ME)); 1090 Inst = TmpInst; 1091 break; 1092 } 1093 case PPC::RLWIMIbm: 1094 case PPC::RLWIMIbm_rec: { 1095 unsigned MB, ME; 1096 int64_t BM = Inst.getOperand(3).getImm(); 1097 if (!isRunOfOnes(BM, MB, ME)) 1098 break; 1099 1100 MCInst TmpInst; 1101 TmpInst.setOpcode(Opcode == PPC::RLWIMIbm ? PPC::RLWIMI : PPC::RLWIMI_rec); 1102 TmpInst.addOperand(Inst.getOperand(0)); 1103 TmpInst.addOperand(Inst.getOperand(0)); // The tied operand. 1104 TmpInst.addOperand(Inst.getOperand(1)); 1105 TmpInst.addOperand(Inst.getOperand(2)); 1106 TmpInst.addOperand(MCOperand::createImm(MB)); 1107 TmpInst.addOperand(MCOperand::createImm(ME)); 1108 Inst = TmpInst; 1109 break; 1110 } 1111 case PPC::RLWNMbm: 1112 case PPC::RLWNMbm_rec: { 1113 unsigned MB, ME; 1114 int64_t BM = Inst.getOperand(3).getImm(); 1115 if (!isRunOfOnes(BM, MB, ME)) 1116 break; 1117 1118 MCInst TmpInst; 1119 TmpInst.setOpcode(Opcode == PPC::RLWNMbm ? PPC::RLWNM : PPC::RLWNM_rec); 1120 TmpInst.addOperand(Inst.getOperand(0)); 1121 TmpInst.addOperand(Inst.getOperand(1)); 1122 TmpInst.addOperand(Inst.getOperand(2)); 1123 TmpInst.addOperand(MCOperand::createImm(MB)); 1124 TmpInst.addOperand(MCOperand::createImm(ME)); 1125 Inst = TmpInst; 1126 break; 1127 } 1128 case PPC::MFTB: { 1129 if (getSTI().getFeatureBits()[PPC::FeatureMFTB]) { 1130 assert(Inst.getNumOperands() == 2 && "Expecting two operands"); 1131 Inst.setOpcode(PPC::MFSPR); 1132 } 1133 break; 1134 } 1135 case PPC::CP_COPYx: 1136 case PPC::CP_COPY_FIRST: { 1137 MCInst TmpInst; 1138 TmpInst.setOpcode(PPC::CP_COPY); 1139 TmpInst.addOperand(Inst.getOperand(0)); 1140 TmpInst.addOperand(Inst.getOperand(1)); 1141 TmpInst.addOperand(MCOperand::createImm(Opcode == PPC::CP_COPYx ? 0 : 1)); 1142 1143 Inst = TmpInst; 1144 break; 1145 } 1146 case PPC::CP_PASTEx : 1147 case PPC::CP_PASTE_LAST: { 1148 MCInst TmpInst; 1149 TmpInst.setOpcode(Opcode == PPC::CP_PASTEx ? PPC::CP_PASTE 1150 : PPC::CP_PASTE_rec); 1151 TmpInst.addOperand(Inst.getOperand(0)); 1152 TmpInst.addOperand(Inst.getOperand(1)); 1153 TmpInst.addOperand(MCOperand::createImm(Opcode == PPC::CP_PASTEx ? 0 : 1)); 1154 1155 Inst = TmpInst; 1156 break; 1157 } 1158 } 1159 } 1160 1161 static std::string PPCMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, 1162 unsigned VariantID = 0); 1163 1164 bool PPCAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, 1165 OperandVector &Operands, 1166 MCStreamer &Out, uint64_t &ErrorInfo, 1167 bool MatchingInlineAsm) { 1168 MCInst Inst; 1169 1170 switch (MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm)) { 1171 case Match_Success: 1172 // Post-process instructions (typically extended mnemonics) 1173 ProcessInstruction(Inst, Operands); 1174 Inst.setLoc(IDLoc); 1175 Out.emitInstruction(Inst, getSTI()); 1176 return false; 1177 case Match_MissingFeature: 1178 return Error(IDLoc, "instruction use requires an option to be enabled"); 1179 case Match_MnemonicFail: { 1180 FeatureBitset FBS = ComputeAvailableFeatures(getSTI().getFeatureBits()); 1181 std::string Suggestion = PPCMnemonicSpellCheck( 1182 ((PPCOperand &)*Operands[0]).getToken(), FBS); 1183 return Error(IDLoc, "invalid instruction" + Suggestion, 1184 ((PPCOperand &)*Operands[0]).getLocRange()); 1185 } 1186 case Match_InvalidOperand: { 1187 SMLoc ErrorLoc = IDLoc; 1188 if (ErrorInfo != ~0ULL) { 1189 if (ErrorInfo >= Operands.size()) 1190 return Error(IDLoc, "too few operands for instruction"); 1191 1192 ErrorLoc = ((PPCOperand &)*Operands[ErrorInfo]).getStartLoc(); 1193 if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 1194 } 1195 1196 return Error(ErrorLoc, "invalid operand for instruction"); 1197 } 1198 } 1199 1200 llvm_unreachable("Implement any new match types added!"); 1201 } 1202 1203 bool PPCAsmParser::MatchRegisterName(unsigned &RegNo, int64_t &IntVal) { 1204 if (getParser().getTok().is(AsmToken::Identifier)) { 1205 StringRef Name = getParser().getTok().getString(); 1206 if (Name.equals_lower("lr")) { 1207 RegNo = isPPC64()? PPC::LR8 : PPC::LR; 1208 IntVal = 8; 1209 } else if (Name.equals_lower("ctr")) { 1210 RegNo = isPPC64()? PPC::CTR8 : PPC::CTR; 1211 IntVal = 9; 1212 } else if (Name.equals_lower("vrsave")) { 1213 RegNo = PPC::VRSAVE; 1214 IntVal = 256; 1215 } else if (Name.startswith_lower("r") && 1216 !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) { 1217 RegNo = isPPC64()? XRegs[IntVal] : RRegs[IntVal]; 1218 } else if (Name.startswith_lower("f") && 1219 !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) { 1220 RegNo = FRegs[IntVal]; 1221 } else if (Name.startswith_lower("vs") && 1222 !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 64) { 1223 RegNo = VSRegs[IntVal]; 1224 } else if (Name.startswith_lower("v") && 1225 !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) { 1226 RegNo = VRegs[IntVal]; 1227 } else if (Name.startswith_lower("cr") && 1228 !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 8) { 1229 RegNo = CRRegs[IntVal]; 1230 } else 1231 return true; 1232 getParser().Lex(); 1233 return false; 1234 } 1235 return true; 1236 } 1237 1238 bool PPCAsmParser:: 1239 ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) { 1240 if (tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success) 1241 return TokError("invalid register name"); 1242 return false; 1243 } 1244 1245 OperandMatchResultTy PPCAsmParser::tryParseRegister(unsigned &RegNo, 1246 SMLoc &StartLoc, 1247 SMLoc &EndLoc) { 1248 const AsmToken &Tok = getParser().getTok(); 1249 StartLoc = Tok.getLoc(); 1250 EndLoc = Tok.getEndLoc(); 1251 RegNo = 0; 1252 int64_t IntVal; 1253 if (MatchRegisterName(RegNo, IntVal)) 1254 return MatchOperand_NoMatch; 1255 return MatchOperand_Success; 1256 } 1257 1258 /// Extract \code @l/@ha \endcode modifier from expression. Recursively scan 1259 /// the expression and check for VK_PPC_LO/HI/HA 1260 /// symbol variants. If all symbols with modifier use the same 1261 /// variant, return the corresponding PPCMCExpr::VariantKind, 1262 /// and a modified expression using the default symbol variant. 1263 /// Otherwise, return NULL. 1264 const MCExpr *PPCAsmParser:: 1265 ExtractModifierFromExpr(const MCExpr *E, 1266 PPCMCExpr::VariantKind &Variant) { 1267 MCContext &Context = getParser().getContext(); 1268 Variant = PPCMCExpr::VK_PPC_None; 1269 1270 switch (E->getKind()) { 1271 case MCExpr::Target: 1272 case MCExpr::Constant: 1273 return nullptr; 1274 1275 case MCExpr::SymbolRef: { 1276 const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 1277 1278 switch (SRE->getKind()) { 1279 case MCSymbolRefExpr::VK_PPC_LO: 1280 Variant = PPCMCExpr::VK_PPC_LO; 1281 break; 1282 case MCSymbolRefExpr::VK_PPC_HI: 1283 Variant = PPCMCExpr::VK_PPC_HI; 1284 break; 1285 case MCSymbolRefExpr::VK_PPC_HA: 1286 Variant = PPCMCExpr::VK_PPC_HA; 1287 break; 1288 case MCSymbolRefExpr::VK_PPC_HIGH: 1289 Variant = PPCMCExpr::VK_PPC_HIGH; 1290 break; 1291 case MCSymbolRefExpr::VK_PPC_HIGHA: 1292 Variant = PPCMCExpr::VK_PPC_HIGHA; 1293 break; 1294 case MCSymbolRefExpr::VK_PPC_HIGHER: 1295 Variant = PPCMCExpr::VK_PPC_HIGHER; 1296 break; 1297 case MCSymbolRefExpr::VK_PPC_HIGHERA: 1298 Variant = PPCMCExpr::VK_PPC_HIGHERA; 1299 break; 1300 case MCSymbolRefExpr::VK_PPC_HIGHEST: 1301 Variant = PPCMCExpr::VK_PPC_HIGHEST; 1302 break; 1303 case MCSymbolRefExpr::VK_PPC_HIGHESTA: 1304 Variant = PPCMCExpr::VK_PPC_HIGHESTA; 1305 break; 1306 default: 1307 return nullptr; 1308 } 1309 1310 return MCSymbolRefExpr::create(&SRE->getSymbol(), Context); 1311 } 1312 1313 case MCExpr::Unary: { 1314 const MCUnaryExpr *UE = cast<MCUnaryExpr>(E); 1315 const MCExpr *Sub = ExtractModifierFromExpr(UE->getSubExpr(), Variant); 1316 if (!Sub) 1317 return nullptr; 1318 return MCUnaryExpr::create(UE->getOpcode(), Sub, Context); 1319 } 1320 1321 case MCExpr::Binary: { 1322 const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 1323 PPCMCExpr::VariantKind LHSVariant, RHSVariant; 1324 const MCExpr *LHS = ExtractModifierFromExpr(BE->getLHS(), LHSVariant); 1325 const MCExpr *RHS = ExtractModifierFromExpr(BE->getRHS(), RHSVariant); 1326 1327 if (!LHS && !RHS) 1328 return nullptr; 1329 1330 if (!LHS) LHS = BE->getLHS(); 1331 if (!RHS) RHS = BE->getRHS(); 1332 1333 if (LHSVariant == PPCMCExpr::VK_PPC_None) 1334 Variant = RHSVariant; 1335 else if (RHSVariant == PPCMCExpr::VK_PPC_None) 1336 Variant = LHSVariant; 1337 else if (LHSVariant == RHSVariant) 1338 Variant = LHSVariant; 1339 else 1340 return nullptr; 1341 1342 return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, Context); 1343 } 1344 } 1345 1346 llvm_unreachable("Invalid expression kind!"); 1347 } 1348 1349 /// Find all VK_TLSGD/VK_TLSLD symbol references in expression and replace 1350 /// them by VK_PPC_TLSGD/VK_PPC_TLSLD. This is necessary to avoid having 1351 /// _GLOBAL_OFFSET_TABLE_ created via ELFObjectWriter::RelocNeedsGOT. 1352 /// FIXME: This is a hack. 1353 const MCExpr *PPCAsmParser:: 1354 FixupVariantKind(const MCExpr *E) { 1355 MCContext &Context = getParser().getContext(); 1356 1357 switch (E->getKind()) { 1358 case MCExpr::Target: 1359 case MCExpr::Constant: 1360 return E; 1361 1362 case MCExpr::SymbolRef: { 1363 const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 1364 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None; 1365 1366 switch (SRE->getKind()) { 1367 case MCSymbolRefExpr::VK_TLSGD: 1368 Variant = MCSymbolRefExpr::VK_PPC_TLSGD; 1369 break; 1370 case MCSymbolRefExpr::VK_TLSLD: 1371 Variant = MCSymbolRefExpr::VK_PPC_TLSLD; 1372 break; 1373 default: 1374 return E; 1375 } 1376 return MCSymbolRefExpr::create(&SRE->getSymbol(), Variant, Context); 1377 } 1378 1379 case MCExpr::Unary: { 1380 const MCUnaryExpr *UE = cast<MCUnaryExpr>(E); 1381 const MCExpr *Sub = FixupVariantKind(UE->getSubExpr()); 1382 if (Sub == UE->getSubExpr()) 1383 return E; 1384 return MCUnaryExpr::create(UE->getOpcode(), Sub, Context); 1385 } 1386 1387 case MCExpr::Binary: { 1388 const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 1389 const MCExpr *LHS = FixupVariantKind(BE->getLHS()); 1390 const MCExpr *RHS = FixupVariantKind(BE->getRHS()); 1391 if (LHS == BE->getLHS() && RHS == BE->getRHS()) 1392 return E; 1393 return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, Context); 1394 } 1395 } 1396 1397 llvm_unreachable("Invalid expression kind!"); 1398 } 1399 1400 /// ParseExpression. This differs from the default "parseExpression" in that 1401 /// it handles modifiers. 1402 bool PPCAsmParser:: 1403 ParseExpression(const MCExpr *&EVal) { 1404 1405 if (isDarwin()) 1406 return ParseDarwinExpression(EVal); 1407 1408 // (ELF Platforms) 1409 // Handle \code @l/@ha \endcode 1410 if (getParser().parseExpression(EVal)) 1411 return true; 1412 1413 EVal = FixupVariantKind(EVal); 1414 1415 PPCMCExpr::VariantKind Variant; 1416 const MCExpr *E = ExtractModifierFromExpr(EVal, Variant); 1417 if (E) 1418 EVal = PPCMCExpr::create(Variant, E, getParser().getContext()); 1419 1420 return false; 1421 } 1422 1423 /// ParseDarwinExpression. (MachO Platforms) 1424 /// This differs from the default "parseExpression" in that it handles detection 1425 /// of the \code hi16(), ha16() and lo16() \endcode modifiers. At present, 1426 /// parseExpression() doesn't recognise the modifiers when in the Darwin/MachO 1427 /// syntax form so it is done here. TODO: Determine if there is merit in 1428 /// arranging for this to be done at a higher level. 1429 bool PPCAsmParser:: 1430 ParseDarwinExpression(const MCExpr *&EVal) { 1431 MCAsmParser &Parser = getParser(); 1432 PPCMCExpr::VariantKind Variant = PPCMCExpr::VK_PPC_None; 1433 switch (getLexer().getKind()) { 1434 default: 1435 break; 1436 case AsmToken::Identifier: 1437 // Compiler-generated Darwin identifiers begin with L,l,_ or "; thus 1438 // something starting with any other char should be part of the 1439 // asm syntax. If handwritten asm includes an identifier like lo16, 1440 // then all bets are off - but no-one would do that, right? 1441 StringRef poss = Parser.getTok().getString(); 1442 if (poss.equals_lower("lo16")) { 1443 Variant = PPCMCExpr::VK_PPC_LO; 1444 } else if (poss.equals_lower("hi16")) { 1445 Variant = PPCMCExpr::VK_PPC_HI; 1446 } else if (poss.equals_lower("ha16")) { 1447 Variant = PPCMCExpr::VK_PPC_HA; 1448 } 1449 if (Variant != PPCMCExpr::VK_PPC_None) { 1450 Parser.Lex(); // Eat the xx16 1451 if (getLexer().isNot(AsmToken::LParen)) 1452 return Error(Parser.getTok().getLoc(), "expected '('"); 1453 Parser.Lex(); // Eat the '(' 1454 } 1455 break; 1456 } 1457 1458 if (getParser().parseExpression(EVal)) 1459 return true; 1460 1461 if (Variant != PPCMCExpr::VK_PPC_None) { 1462 if (getLexer().isNot(AsmToken::RParen)) 1463 return Error(Parser.getTok().getLoc(), "expected ')'"); 1464 Parser.Lex(); // Eat the ')' 1465 EVal = PPCMCExpr::create(Variant, EVal, getParser().getContext()); 1466 } 1467 return false; 1468 } 1469 1470 /// ParseOperand 1471 /// This handles registers in the form 'NN', '%rNN' for ELF platforms and 1472 /// rNN for MachO. 1473 bool PPCAsmParser::ParseOperand(OperandVector &Operands) { 1474 MCAsmParser &Parser = getParser(); 1475 SMLoc S = Parser.getTok().getLoc(); 1476 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 1477 const MCExpr *EVal; 1478 1479 // Attempt to parse the next token as an immediate 1480 switch (getLexer().getKind()) { 1481 // Special handling for register names. These are interpreted 1482 // as immediates corresponding to the register number. 1483 case AsmToken::Percent: 1484 Parser.Lex(); // Eat the '%'. 1485 unsigned RegNo; 1486 int64_t IntVal; 1487 if (MatchRegisterName(RegNo, IntVal)) 1488 return Error(S, "invalid register name"); 1489 1490 Operands.push_back(PPCOperand::CreateImm(IntVal, S, E, isPPC64())); 1491 return false; 1492 1493 case AsmToken::Identifier: 1494 case AsmToken::LParen: 1495 case AsmToken::Plus: 1496 case AsmToken::Minus: 1497 case AsmToken::Integer: 1498 case AsmToken::Dot: 1499 case AsmToken::Dollar: 1500 case AsmToken::Exclaim: 1501 case AsmToken::Tilde: 1502 // Note that non-register-name identifiers from the compiler will begin 1503 // with '_', 'L'/'l' or '"'. Of course, handwritten asm could include 1504 // identifiers like r31foo - so we fall through in the event that parsing 1505 // a register name fails. 1506 if (isDarwin()) { 1507 unsigned RegNo; 1508 int64_t IntVal; 1509 if (!MatchRegisterName(RegNo, IntVal)) { 1510 Operands.push_back(PPCOperand::CreateImm(IntVal, S, E, isPPC64())); 1511 return false; 1512 } 1513 } 1514 // All other expressions 1515 1516 if (!ParseExpression(EVal)) 1517 break; 1518 // Fall-through 1519 LLVM_FALLTHROUGH; 1520 default: 1521 return Error(S, "unknown operand"); 1522 } 1523 1524 // Push the parsed operand into the list of operands 1525 Operands.push_back(PPCOperand::CreateFromMCExpr(EVal, S, E, isPPC64())); 1526 1527 // Check whether this is a TLS call expression 1528 bool TLSCall = false; 1529 if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(EVal)) 1530 TLSCall = Ref->getSymbol().getName() == "__tls_get_addr"; 1531 1532 if (TLSCall && getLexer().is(AsmToken::LParen)) { 1533 const MCExpr *TLSSym; 1534 1535 Parser.Lex(); // Eat the '('. 1536 S = Parser.getTok().getLoc(); 1537 if (ParseExpression(TLSSym)) 1538 return Error(S, "invalid TLS call expression"); 1539 if (getLexer().isNot(AsmToken::RParen)) 1540 return Error(Parser.getTok().getLoc(), "missing ')'"); 1541 E = Parser.getTok().getLoc(); 1542 Parser.Lex(); // Eat the ')'. 1543 1544 Operands.push_back(PPCOperand::CreateFromMCExpr(TLSSym, S, E, isPPC64())); 1545 } 1546 1547 // Otherwise, check for D-form memory operands 1548 if (!TLSCall && getLexer().is(AsmToken::LParen)) { 1549 Parser.Lex(); // Eat the '('. 1550 S = Parser.getTok().getLoc(); 1551 1552 int64_t IntVal; 1553 switch (getLexer().getKind()) { 1554 case AsmToken::Percent: 1555 Parser.Lex(); // Eat the '%'. 1556 unsigned RegNo; 1557 if (MatchRegisterName(RegNo, IntVal)) 1558 return Error(S, "invalid register name"); 1559 break; 1560 1561 case AsmToken::Integer: 1562 if (isDarwin()) 1563 return Error(S, "unexpected integer value"); 1564 else if (getParser().parseAbsoluteExpression(IntVal) || IntVal < 0 || 1565 IntVal > 31) 1566 return Error(S, "invalid register number"); 1567 break; 1568 case AsmToken::Identifier: 1569 if (isDarwin()) { 1570 unsigned RegNo; 1571 if (!MatchRegisterName(RegNo, IntVal)) { 1572 break; 1573 } 1574 } 1575 LLVM_FALLTHROUGH; 1576 1577 default: 1578 return Error(S, "invalid memory operand"); 1579 } 1580 1581 E = Parser.getTok().getLoc(); 1582 if (parseToken(AsmToken::RParen, "missing ')'")) 1583 return true; 1584 Operands.push_back(PPCOperand::CreateImm(IntVal, S, E, isPPC64())); 1585 } 1586 1587 return false; 1588 } 1589 1590 /// Parse an instruction mnemonic followed by its operands. 1591 bool PPCAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name, 1592 SMLoc NameLoc, OperandVector &Operands) { 1593 // The first operand is the token for the instruction name. 1594 // If the next character is a '+' or '-', we need to add it to the 1595 // instruction name, to match what TableGen is doing. 1596 std::string NewOpcode; 1597 if (parseOptionalToken(AsmToken::Plus)) { 1598 NewOpcode = std::string(Name); 1599 NewOpcode += '+'; 1600 Name = NewOpcode; 1601 } 1602 if (parseOptionalToken(AsmToken::Minus)) { 1603 NewOpcode = std::string(Name); 1604 NewOpcode += '-'; 1605 Name = NewOpcode; 1606 } 1607 // If the instruction ends in a '.', we need to create a separate 1608 // token for it, to match what TableGen is doing. 1609 size_t Dot = Name.find('.'); 1610 StringRef Mnemonic = Name.slice(0, Dot); 1611 if (!NewOpcode.empty()) // Underlying memory for Name is volatile. 1612 Operands.push_back( 1613 PPCOperand::CreateTokenWithStringCopy(Mnemonic, NameLoc, isPPC64())); 1614 else 1615 Operands.push_back(PPCOperand::CreateToken(Mnemonic, NameLoc, isPPC64())); 1616 if (Dot != StringRef::npos) { 1617 SMLoc DotLoc = SMLoc::getFromPointer(NameLoc.getPointer() + Dot); 1618 StringRef DotStr = Name.slice(Dot, StringRef::npos); 1619 if (!NewOpcode.empty()) // Underlying memory for Name is volatile. 1620 Operands.push_back( 1621 PPCOperand::CreateTokenWithStringCopy(DotStr, DotLoc, isPPC64())); 1622 else 1623 Operands.push_back(PPCOperand::CreateToken(DotStr, DotLoc, isPPC64())); 1624 } 1625 1626 // If there are no more operands then finish 1627 if (parseOptionalToken(AsmToken::EndOfStatement)) 1628 return false; 1629 1630 // Parse the first operand 1631 if (ParseOperand(Operands)) 1632 return true; 1633 1634 while (!parseOptionalToken(AsmToken::EndOfStatement)) { 1635 if (parseToken(AsmToken::Comma) || ParseOperand(Operands)) 1636 return true; 1637 } 1638 1639 // We'll now deal with an unfortunate special case: the syntax for the dcbt 1640 // and dcbtst instructions differs for server vs. embedded cores. 1641 // The syntax for dcbt is: 1642 // dcbt ra, rb, th [server] 1643 // dcbt th, ra, rb [embedded] 1644 // where th can be omitted when it is 0. dcbtst is the same. We take the 1645 // server form to be the default, so swap the operands if we're parsing for 1646 // an embedded core (they'll be swapped again upon printing). 1647 if (getSTI().getFeatureBits()[PPC::FeatureBookE] && 1648 Operands.size() == 4 && 1649 (Name == "dcbt" || Name == "dcbtst")) { 1650 std::swap(Operands[1], Operands[3]); 1651 std::swap(Operands[2], Operands[1]); 1652 } 1653 1654 return false; 1655 } 1656 1657 /// ParseDirective parses the PPC specific directives 1658 bool PPCAsmParser::ParseDirective(AsmToken DirectiveID) { 1659 StringRef IDVal = DirectiveID.getIdentifier(); 1660 if (isDarwin()) { 1661 if (IDVal == ".machine") 1662 ParseDarwinDirectiveMachine(DirectiveID.getLoc()); 1663 else 1664 return true; 1665 } else if (IDVal == ".word") 1666 ParseDirectiveWord(2, DirectiveID); 1667 else if (IDVal == ".llong") 1668 ParseDirectiveWord(8, DirectiveID); 1669 else if (IDVal == ".tc") 1670 ParseDirectiveTC(isPPC64() ? 8 : 4, DirectiveID); 1671 else if (IDVal == ".machine") 1672 ParseDirectiveMachine(DirectiveID.getLoc()); 1673 else if (IDVal == ".abiversion") 1674 ParseDirectiveAbiVersion(DirectiveID.getLoc()); 1675 else if (IDVal == ".localentry") 1676 ParseDirectiveLocalEntry(DirectiveID.getLoc()); 1677 else 1678 return true; 1679 return false; 1680 } 1681 1682 /// ParseDirectiveWord 1683 /// ::= .word [ expression (, expression)* ] 1684 bool PPCAsmParser::ParseDirectiveWord(unsigned Size, AsmToken ID) { 1685 auto parseOp = [&]() -> bool { 1686 const MCExpr *Value; 1687 SMLoc ExprLoc = getParser().getTok().getLoc(); 1688 if (getParser().parseExpression(Value)) 1689 return true; 1690 if (const auto *MCE = dyn_cast<MCConstantExpr>(Value)) { 1691 assert(Size <= 8 && "Invalid size"); 1692 uint64_t IntValue = MCE->getValue(); 1693 if (!isUIntN(8 * Size, IntValue) && !isIntN(8 * Size, IntValue)) 1694 return Error(ExprLoc, "literal value out of range for '" + 1695 ID.getIdentifier() + "' directive"); 1696 getStreamer().emitIntValue(IntValue, Size); 1697 } else 1698 getStreamer().emitValue(Value, Size, ExprLoc); 1699 return false; 1700 }; 1701 1702 if (parseMany(parseOp)) 1703 return addErrorSuffix(" in '" + ID.getIdentifier() + "' directive"); 1704 return false; 1705 } 1706 1707 /// ParseDirectiveTC 1708 /// ::= .tc [ symbol (, expression)* ] 1709 bool PPCAsmParser::ParseDirectiveTC(unsigned Size, AsmToken ID) { 1710 MCAsmParser &Parser = getParser(); 1711 // Skip TC symbol, which is only used with XCOFF. 1712 while (getLexer().isNot(AsmToken::EndOfStatement) 1713 && getLexer().isNot(AsmToken::Comma)) 1714 Parser.Lex(); 1715 if (parseToken(AsmToken::Comma)) 1716 return addErrorSuffix(" in '.tc' directive"); 1717 1718 // Align to word size. 1719 getParser().getStreamer().emitValueToAlignment(Size); 1720 1721 // Emit expressions. 1722 return ParseDirectiveWord(Size, ID); 1723 } 1724 1725 /// ParseDirectiveMachine (ELF platforms) 1726 /// ::= .machine [ cpu | "push" | "pop" ] 1727 bool PPCAsmParser::ParseDirectiveMachine(SMLoc L) { 1728 MCAsmParser &Parser = getParser(); 1729 if (Parser.getTok().isNot(AsmToken::Identifier) && 1730 Parser.getTok().isNot(AsmToken::String)) 1731 return Error(L, "unexpected token in '.machine' directive"); 1732 1733 StringRef CPU = Parser.getTok().getIdentifier(); 1734 1735 // FIXME: Right now, the parser always allows any available 1736 // instruction, so the .machine directive is not useful. 1737 // Implement ".machine any" (by doing nothing) for the benefit 1738 // of existing assembler code. Likewise, we can then implement 1739 // ".machine push" and ".machine pop" as no-op. 1740 if (CPU != "any" && CPU != "push" && CPU != "pop") 1741 return TokError("unrecognized machine type"); 1742 1743 Parser.Lex(); 1744 1745 if (parseToken(AsmToken::EndOfStatement)) 1746 return addErrorSuffix(" in '.machine' directive"); 1747 1748 PPCTargetStreamer *TStreamer = static_cast<PPCTargetStreamer *>( 1749 getParser().getStreamer().getTargetStreamer()); 1750 if (TStreamer != nullptr) 1751 TStreamer->emitMachine(CPU); 1752 1753 return false; 1754 } 1755 1756 /// ParseDarwinDirectiveMachine (Mach-o platforms) 1757 /// ::= .machine cpu-identifier 1758 bool PPCAsmParser::ParseDarwinDirectiveMachine(SMLoc L) { 1759 MCAsmParser &Parser = getParser(); 1760 if (Parser.getTok().isNot(AsmToken::Identifier) && 1761 Parser.getTok().isNot(AsmToken::String)) 1762 return Error(L, "unexpected token in directive"); 1763 1764 StringRef CPU = Parser.getTok().getIdentifier(); 1765 Parser.Lex(); 1766 1767 // FIXME: this is only the 'default' set of cpu variants. 1768 // However we don't act on this information at present, this is simply 1769 // allowing parsing to proceed with minimal sanity checking. 1770 if (check(CPU != "ppc7400" && CPU != "ppc" && CPU != "ppc64", L, 1771 "unrecognized cpu type") || 1772 check(isPPC64() && (CPU == "ppc7400" || CPU == "ppc"), L, 1773 "wrong cpu type specified for 64bit") || 1774 check(!isPPC64() && CPU == "ppc64", L, 1775 "wrong cpu type specified for 32bit") || 1776 parseToken(AsmToken::EndOfStatement)) 1777 return addErrorSuffix(" in '.machine' directive"); 1778 return false; 1779 } 1780 1781 /// ParseDirectiveAbiVersion 1782 /// ::= .abiversion constant-expression 1783 bool PPCAsmParser::ParseDirectiveAbiVersion(SMLoc L) { 1784 int64_t AbiVersion; 1785 if (check(getParser().parseAbsoluteExpression(AbiVersion), L, 1786 "expected constant expression") || 1787 parseToken(AsmToken::EndOfStatement)) 1788 return addErrorSuffix(" in '.abiversion' directive"); 1789 1790 PPCTargetStreamer *TStreamer = static_cast<PPCTargetStreamer *>( 1791 getParser().getStreamer().getTargetStreamer()); 1792 if (TStreamer != nullptr) 1793 TStreamer->emitAbiVersion(AbiVersion); 1794 1795 return false; 1796 } 1797 1798 /// ParseDirectiveLocalEntry 1799 /// ::= .localentry symbol, expression 1800 bool PPCAsmParser::ParseDirectiveLocalEntry(SMLoc L) { 1801 StringRef Name; 1802 if (getParser().parseIdentifier(Name)) 1803 return Error(L, "expected identifier in '.localentry' directive"); 1804 1805 MCSymbolELF *Sym = cast<MCSymbolELF>(getContext().getOrCreateSymbol(Name)); 1806 const MCExpr *Expr; 1807 1808 if (parseToken(AsmToken::Comma) || 1809 check(getParser().parseExpression(Expr), L, "expected expression") || 1810 parseToken(AsmToken::EndOfStatement)) 1811 return addErrorSuffix(" in '.localentry' directive"); 1812 1813 PPCTargetStreamer *TStreamer = static_cast<PPCTargetStreamer *>( 1814 getParser().getStreamer().getTargetStreamer()); 1815 if (TStreamer != nullptr) 1816 TStreamer->emitLocalEntry(Sym, Expr); 1817 1818 return false; 1819 } 1820 1821 1822 1823 /// Force static initialization. 1824 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCAsmParser() { 1825 RegisterMCAsmParser<PPCAsmParser> A(getThePPC32Target()); 1826 RegisterMCAsmParser<PPCAsmParser> B(getThePPC64Target()); 1827 RegisterMCAsmParser<PPCAsmParser> C(getThePPC64LETarget()); 1828 } 1829 1830 #define GET_REGISTER_MATCHER 1831 #define GET_MATCHER_IMPLEMENTATION 1832 #define GET_MNEMONIC_SPELL_CHECKER 1833 #include "PPCGenAsmMatcher.inc" 1834 1835 // Define this matcher function after the auto-generated include so we 1836 // have the match class enum definitions. 1837 unsigned PPCAsmParser::validateTargetOperandClass(MCParsedAsmOperand &AsmOp, 1838 unsigned Kind) { 1839 // If the kind is a token for a literal immediate, check if our asm 1840 // operand matches. This is for InstAliases which have a fixed-value 1841 // immediate in the syntax. 1842 int64_t ImmVal; 1843 switch (Kind) { 1844 case MCK_0: ImmVal = 0; break; 1845 case MCK_1: ImmVal = 1; break; 1846 case MCK_2: ImmVal = 2; break; 1847 case MCK_3: ImmVal = 3; break; 1848 case MCK_4: ImmVal = 4; break; 1849 case MCK_5: ImmVal = 5; break; 1850 case MCK_6: ImmVal = 6; break; 1851 case MCK_7: ImmVal = 7; break; 1852 default: return Match_InvalidOperand; 1853 } 1854 1855 PPCOperand &Op = static_cast<PPCOperand &>(AsmOp); 1856 if (Op.isImm() && Op.getImm() == ImmVal) 1857 return Match_Success; 1858 1859 return Match_InvalidOperand; 1860 } 1861 1862 const MCExpr * 1863 PPCAsmParser::applyModifierToExpr(const MCExpr *E, 1864 MCSymbolRefExpr::VariantKind Variant, 1865 MCContext &Ctx) { 1866 switch (Variant) { 1867 case MCSymbolRefExpr::VK_PPC_LO: 1868 return PPCMCExpr::create(PPCMCExpr::VK_PPC_LO, E, Ctx); 1869 case MCSymbolRefExpr::VK_PPC_HI: 1870 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HI, E, Ctx); 1871 case MCSymbolRefExpr::VK_PPC_HA: 1872 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HA, E, Ctx); 1873 case MCSymbolRefExpr::VK_PPC_HIGH: 1874 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGH, E, Ctx); 1875 case MCSymbolRefExpr::VK_PPC_HIGHA: 1876 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHA, E, Ctx); 1877 case MCSymbolRefExpr::VK_PPC_HIGHER: 1878 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHER, E, Ctx); 1879 case MCSymbolRefExpr::VK_PPC_HIGHERA: 1880 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHERA, E, Ctx); 1881 case MCSymbolRefExpr::VK_PPC_HIGHEST: 1882 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHEST, E, Ctx); 1883 case MCSymbolRefExpr::VK_PPC_HIGHESTA: 1884 return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHESTA, E, Ctx); 1885 default: 1886 return nullptr; 1887 } 1888 } 1889