| //===-- MipsMCCodeEmitter.cpp - Convert Mips Code to Machine Code ---------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file implements the MipsMCCodeEmitter class. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "MipsMCCodeEmitter.h" | |
| #include "MCTargetDesc/MipsFixupKinds.h" | |
| #include "MCTargetDesc/MipsMCExpr.h" | |
| #include "MCTargetDesc/MipsMCTargetDesc.h" | |
| #include "llvm/ADT/APFloat.h" | |
| #include "llvm/ADT/APInt.h" | |
| #include "llvm/ADT/SmallVector.h" | |
| #include "llvm/MC/MCContext.h" | |
| #include "llvm/MC/MCExpr.h" | |
| #include "llvm/MC/MCFixup.h" | |
| #include "llvm/MC/MCInst.h" | |
| #include "llvm/MC/MCInstrDesc.h" | |
| #include "llvm/MC/MCInstrInfo.h" | |
| #include "llvm/MC/MCRegisterInfo.h" | |
| #include "llvm/MC/MCSubtargetInfo.h" | |
| #include "llvm/Support/Casting.h" | |
| #include "llvm/Support/ErrorHandling.h" | |
| #include "llvm/Support/raw_ostream.h" | |
| #include <cassert> | |
| #include <cstdint> | |
| using namespace llvm; | |
| #define DEBUG_TYPE "mccodeemitter" | |
| #define GET_INSTRMAP_INFO | |
| #include "MipsGenInstrInfo.inc" | |
| #undef GET_INSTRMAP_INFO | |
| namespace llvm { | |
| MCCodeEmitter *createMipsMCCodeEmitterEB(const MCInstrInfo &MCII, | |
| MCContext &Ctx) { | |
| return new MipsMCCodeEmitter(MCII, Ctx, false); | |
| } | |
| MCCodeEmitter *createMipsMCCodeEmitterEL(const MCInstrInfo &MCII, | |
| MCContext &Ctx) { | |
| return new MipsMCCodeEmitter(MCII, Ctx, true); | |
| } | |
| } // end namespace llvm | |
| // If the D<shift> instruction has a shift amount that is greater | |
| // than 31 (checked in calling routine), lower it to a D<shift>32 instruction | |
| static void LowerLargeShift(MCInst& Inst) { | |
| assert(Inst.getNumOperands() == 3 && "Invalid no. of operands for shift!"); | |
| assert(Inst.getOperand(2).isImm()); | |
| int64_t Shift = Inst.getOperand(2).getImm(); | |
| if (Shift <= 31) | |
| return; // Do nothing | |
| Shift -= 32; | |
| // saminus32 | |
| Inst.getOperand(2).setImm(Shift); | |
| switch (Inst.getOpcode()) { | |
| default: | |
| // Calling function is not synchronized | |
| llvm_unreachable("Unexpected shift instruction"); | |
| case Mips::DSLL: | |
| Inst.setOpcode(Mips::DSLL32); | |
| return; | |
| case Mips::DSRL: | |
| Inst.setOpcode(Mips::DSRL32); | |
| return; | |
| case Mips::DSRA: | |
| Inst.setOpcode(Mips::DSRA32); | |
| return; | |
| case Mips::DROTR: | |
| Inst.setOpcode(Mips::DROTR32); | |
| return; | |
| } | |
| } | |
| // Fix a bad compact branch encoding for beqc/bnec. | |
| void MipsMCCodeEmitter::LowerCompactBranch(MCInst& Inst) const { | |
| // Encoding may be illegal !(rs < rt), but this situation is | |
| // easily fixed. | |
| unsigned RegOp0 = Inst.getOperand(0).getReg(); | |
| unsigned RegOp1 = Inst.getOperand(1).getReg(); | |
| unsigned Reg0 = Ctx.getRegisterInfo()->getEncodingValue(RegOp0); | |
| unsigned Reg1 = Ctx.getRegisterInfo()->getEncodingValue(RegOp1); | |
| if (Inst.getOpcode() == Mips::BNEC || Inst.getOpcode() == Mips::BEQC || | |
| Inst.getOpcode() == Mips::BNEC64 || Inst.getOpcode() == Mips::BEQC64) { | |
| assert(Reg0 != Reg1 && "Instruction has bad operands ($rs == $rt)!"); | |
| if (Reg0 < Reg1) | |
| return; | |
| } else if (Inst.getOpcode() == Mips::BNVC || Inst.getOpcode() == Mips::BOVC) { | |
| if (Reg0 >= Reg1) | |
| return; | |
| } else if (Inst.getOpcode() == Mips::BNVC_MMR6 || | |
| Inst.getOpcode() == Mips::BOVC_MMR6) { | |
| if (Reg1 >= Reg0) | |
| return; | |
| } else | |
| llvm_unreachable("Cannot rewrite unknown branch!"); | |
| Inst.getOperand(0).setReg(RegOp1); | |
| Inst.getOperand(1).setReg(RegOp0); | |
| } | |
| bool MipsMCCodeEmitter::isMicroMips(const MCSubtargetInfo &STI) const { | |
| return STI.getFeatureBits()[Mips::FeatureMicroMips]; | |
| } | |
| bool MipsMCCodeEmitter::isMips32r6(const MCSubtargetInfo &STI) const { | |
| return STI.getFeatureBits()[Mips::FeatureMips32r6]; | |
| } | |
| void MipsMCCodeEmitter::EmitByte(unsigned char C, raw_ostream &OS) const { | |
| OS << (char)C; | |
| } | |
| void MipsMCCodeEmitter::emitInstruction(uint64_t Val, unsigned Size, | |
| const MCSubtargetInfo &STI, | |
| raw_ostream &OS) const { | |
| // Output the instruction encoding in little endian byte order. | |
| // Little-endian byte ordering: | |
| // mips32r2: 4 | 3 | 2 | 1 | |
| // microMIPS: 2 | 1 | 4 | 3 | |
| if (IsLittleEndian && Size == 4 && isMicroMips(STI)) { | |
| emitInstruction(Val >> 16, 2, STI, OS); | |
| emitInstruction(Val, 2, STI, OS); | |
| } else { | |
| for (unsigned i = 0; i < Size; ++i) { | |
| unsigned Shift = IsLittleEndian ? i * 8 : (Size - 1 - i) * 8; | |
| EmitByte((Val >> Shift) & 0xff, OS); | |
| } | |
| } | |
| } | |
| /// encodeInstruction - Emit the instruction. | |
| /// Size the instruction with Desc.getSize(). | |
| void MipsMCCodeEmitter:: | |
| encodeInstruction(const MCInst &MI, raw_ostream &OS, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const | |
| { | |
| // Non-pseudo instructions that get changed for direct object | |
| // only based on operand values. | |
| // If this list of instructions get much longer we will move | |
| // the check to a function call. Until then, this is more efficient. | |
| MCInst TmpInst = MI; | |
| switch (MI.getOpcode()) { | |
| // If shift amount is >= 32 it the inst needs to be lowered further | |
| case Mips::DSLL: | |
| case Mips::DSRL: | |
| case Mips::DSRA: | |
| case Mips::DROTR: | |
| LowerLargeShift(TmpInst); | |
| break; | |
| // Compact branches, enforce encoding restrictions. | |
| case Mips::BEQC: | |
| case Mips::BNEC: | |
| case Mips::BEQC64: | |
| case Mips::BNEC64: | |
| case Mips::BOVC: | |
| case Mips::BOVC_MMR6: | |
| case Mips::BNVC: | |
| case Mips::BNVC_MMR6: | |
| LowerCompactBranch(TmpInst); | |
| } | |
| size_t N = Fixups.size(); | |
| uint32_t Binary = getBinaryCodeForInstr(TmpInst, Fixups, STI); | |
| // Check for unimplemented opcodes. | |
| // Unfortunately in MIPS both NOP and SLL will come in with Binary == 0 | |
| // so we have to special check for them. | |
| const unsigned Opcode = TmpInst.getOpcode(); | |
| if ((Opcode != Mips::NOP) && (Opcode != Mips::SLL) && | |
| (Opcode != Mips::SLL_MM) && (Opcode != Mips::SLL_MMR6) && !Binary) | |
| llvm_unreachable("unimplemented opcode in encodeInstruction()"); | |
| int NewOpcode = -1; | |
| if (isMicroMips(STI)) { | |
| if (isMips32r6(STI)) { | |
| NewOpcode = Mips::MipsR62MicroMipsR6(Opcode, Mips::Arch_micromipsr6); | |
| if (NewOpcode == -1) | |
| NewOpcode = Mips::Std2MicroMipsR6(Opcode, Mips::Arch_micromipsr6); | |
| } | |
| else | |
| NewOpcode = Mips::Std2MicroMips(Opcode, Mips::Arch_micromips); | |
| // Check whether it is Dsp instruction. | |
| if (NewOpcode == -1) | |
| NewOpcode = Mips::Dsp2MicroMips(Opcode, Mips::Arch_mmdsp); | |
| if (NewOpcode != -1) { | |
| if (Fixups.size() > N) | |
| Fixups.pop_back(); | |
| TmpInst.setOpcode (NewOpcode); | |
| Binary = getBinaryCodeForInstr(TmpInst, Fixups, STI); | |
| } | |
| if (((MI.getOpcode() == Mips::MOVEP_MM) || | |
| (MI.getOpcode() == Mips::MOVEP_MMR6))) { | |
| unsigned RegPair = getMovePRegPairOpValue(MI, 0, Fixups, STI); | |
| Binary = (Binary & 0xFFFFFC7F) | (RegPair << 7); | |
| } | |
| } | |
| const MCInstrDesc &Desc = MCII.get(TmpInst.getOpcode()); | |
| // Get byte count of instruction | |
| unsigned Size = Desc.getSize(); | |
| if (!Size) | |
| llvm_unreachable("Desc.getSize() returns 0"); | |
| emitInstruction(Binary, Size, STI, OS); | |
| } | |
| /// getBranchTargetOpValue - Return binary encoding of the branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTargetOpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 4. | |
| if (MO.isImm()) return MO.getImm() >> 2; | |
| assert(MO.isExpr() && | |
| "getBranchTargetOpValue expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-4, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_Mips_PC16))); | |
| return 0; | |
| } | |
| /// getBranchTargetOpValue1SImm16 - Return binary encoding of the branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTargetOpValue1SImm16(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 2. | |
| if (MO.isImm()) return MO.getImm() >> 1; | |
| assert(MO.isExpr() && | |
| "getBranchTargetOpValue expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-4, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_Mips_PC16))); | |
| return 0; | |
| } | |
| /// getBranchTargetOpValueMMR6 - Return binary encoding of the branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTargetOpValueMMR6(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 2. | |
| if (MO.isImm()) | |
| return MO.getImm() >> 1; | |
| assert(MO.isExpr() && | |
| "getBranchTargetOpValueMMR6 expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-2, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_Mips_PC16))); | |
| return 0; | |
| } | |
| /// getBranchTargetOpValueLsl2MMR6 - Return binary encoding of the branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTargetOpValueLsl2MMR6(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 4. | |
| if (MO.isImm()) | |
| return MO.getImm() >> 2; | |
| assert(MO.isExpr() && | |
| "getBranchTargetOpValueLsl2MMR6 expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-4, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_Mips_PC16))); | |
| return 0; | |
| } | |
| /// getBranchTarget7OpValueMM - Return binary encoding of the microMIPS branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTarget7OpValueMM(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 2. | |
| if (MO.isImm()) return MO.getImm() >> 1; | |
| assert(MO.isExpr() && | |
| "getBranchTargetOpValueMM expects only expressions or immediates"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Fixups.push_back(MCFixup::create(0, Expr, | |
| MCFixupKind(Mips::fixup_MICROMIPS_PC7_S1))); | |
| return 0; | |
| } | |
| /// getBranchTargetOpValueMMPC10 - Return binary encoding of the microMIPS | |
| /// 10-bit branch target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTargetOpValueMMPC10(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 2. | |
| if (MO.isImm()) return MO.getImm() >> 1; | |
| assert(MO.isExpr() && | |
| "getBranchTargetOpValuePC10 expects only expressions or immediates"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Fixups.push_back(MCFixup::create(0, Expr, | |
| MCFixupKind(Mips::fixup_MICROMIPS_PC10_S1))); | |
| return 0; | |
| } | |
| /// getBranchTargetOpValue - Return binary encoding of the microMIPS branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTargetOpValueMM(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 2. | |
| if (MO.isImm()) return MO.getImm() >> 1; | |
| assert(MO.isExpr() && | |
| "getBranchTargetOpValueMM expects only expressions or immediates"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Fixups.push_back(MCFixup::create(0, Expr, | |
| MCFixupKind(Mips:: | |
| fixup_MICROMIPS_PC16_S1))); | |
| return 0; | |
| } | |
| /// getBranchTarget21OpValue - Return binary encoding of the branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTarget21OpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 4. | |
| if (MO.isImm()) return MO.getImm() >> 2; | |
| assert(MO.isExpr() && | |
| "getBranchTarget21OpValue expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-4, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_MIPS_PC21_S2))); | |
| return 0; | |
| } | |
| /// getBranchTarget21OpValueMM - Return binary encoding of the branch | |
| /// target operand for microMIPS. If the machine operand requires | |
| /// relocation, record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTarget21OpValueMM(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 4. | |
| if (MO.isImm()) return MO.getImm() >> 2; | |
| assert(MO.isExpr() && | |
| "getBranchTarget21OpValueMM expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-4, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_MICROMIPS_PC21_S1))); | |
| return 0; | |
| } | |
| /// getBranchTarget26OpValue - Return binary encoding of the branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getBranchTarget26OpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 4. | |
| if (MO.isImm()) return MO.getImm() >> 2; | |
| assert(MO.isExpr() && | |
| "getBranchTarget26OpValue expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-4, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_MIPS_PC26_S2))); | |
| return 0; | |
| } | |
| /// getBranchTarget26OpValueMM - Return binary encoding of the branch | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter::getBranchTarget26OpValueMM( | |
| const MCInst &MI, unsigned OpNo, SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 2. | |
| if (MO.isImm()) | |
| return MO.getImm() >> 1; | |
| assert(MO.isExpr() && | |
| "getBranchTarget26OpValueMM expects only expressions or immediates"); | |
| const MCExpr *FixupExpression = MCBinaryExpr::createAdd( | |
| MO.getExpr(), MCConstantExpr::create(-4, Ctx), Ctx); | |
| Fixups.push_back(MCFixup::create(0, FixupExpression, | |
| MCFixupKind(Mips::fixup_MICROMIPS_PC26_S1))); | |
| return 0; | |
| } | |
| /// getJumpOffset16OpValue - Return binary encoding of the jump | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getJumpOffset16OpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| if (MO.isImm()) return MO.getImm(); | |
| assert(MO.isExpr() && | |
| "getJumpOffset16OpValue expects only expressions or an immediate"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Mips::Fixups FixupKind = | |
| isMicroMips(STI) ? Mips::fixup_MICROMIPS_LO16 : Mips::fixup_Mips_LO16; | |
| Fixups.push_back(MCFixup::create(0, Expr, MCFixupKind(FixupKind))); | |
| return 0; | |
| } | |
| /// getJumpTargetOpValue - Return binary encoding of the jump | |
| /// target operand. If the machine operand requires relocation, | |
| /// record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getJumpTargetOpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 4. | |
| if (MO.isImm()) return MO.getImm()>>2; | |
| assert(MO.isExpr() && | |
| "getJumpTargetOpValue expects only expressions or an immediate"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Fixups.push_back(MCFixup::create(0, Expr, | |
| MCFixupKind(Mips::fixup_Mips_26))); | |
| return 0; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getJumpTargetOpValueMM(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| // If the destination is an immediate, divide by 2. | |
| if (MO.isImm()) return MO.getImm() >> 1; | |
| assert(MO.isExpr() && | |
| "getJumpTargetOpValueMM expects only expressions or an immediate"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Fixups.push_back(MCFixup::create(0, Expr, | |
| MCFixupKind(Mips::fixup_MICROMIPS_26_S1))); | |
| return 0; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getUImm5Lsl2Encoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| if (MO.isImm()) { | |
| // The immediate is encoded as 'immediate << 2'. | |
| unsigned Res = getMachineOpValue(MI, MO, Fixups, STI); | |
| assert((Res & 3) == 0); | |
| return Res >> 2; | |
| } | |
| assert(MO.isExpr() && | |
| "getUImm5Lsl2Encoding expects only expressions or an immediate"); | |
| return 0; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getSImm3Lsa2Value(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| if (MO.isImm()) { | |
| int Value = MO.getImm(); | |
| return Value >> 2; | |
| } | |
| return 0; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getUImm6Lsl2Encoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| if (MO.isImm()) { | |
| unsigned Value = MO.getImm(); | |
| return Value >> 2; | |
| } | |
| return 0; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getSImm9AddiuspValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| if (MO.isImm()) { | |
| unsigned Binary = (MO.getImm() >> 2) & 0x0000ffff; | |
| return (((Binary & 0x8000) >> 7) | (Binary & 0x00ff)); | |
| } | |
| return 0; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getExprOpValue(const MCExpr *Expr, SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| int64_t Res; | |
| if (Expr->evaluateAsAbsolute(Res)) | |
| return Res; | |
| MCExpr::ExprKind Kind = Expr->getKind(); | |
| if (Kind == MCExpr::Constant) { | |
| return cast<MCConstantExpr>(Expr)->getValue(); | |
| } | |
| if (Kind == MCExpr::Binary) { | |
| unsigned Res = | |
| getExprOpValue(cast<MCBinaryExpr>(Expr)->getLHS(), Fixups, STI); | |
| Res += getExprOpValue(cast<MCBinaryExpr>(Expr)->getRHS(), Fixups, STI); | |
| return Res; | |
| } | |
| if (Kind == MCExpr::Target) { | |
| const MipsMCExpr *MipsExpr = cast<MipsMCExpr>(Expr); | |
| Mips::Fixups FixupKind = Mips::Fixups(0); | |
| switch (MipsExpr->getKind()) { | |
| case MipsMCExpr::MEK_None: | |
| case MipsMCExpr::MEK_Special: | |
| llvm_unreachable("Unhandled fixup kind!"); | |
| break; | |
| case MipsMCExpr::MEK_DTPREL: | |
| // MEK_DTPREL is used for marking TLS DIEExpr only | |
| // and contains a regular sub-expression. | |
| return getExprOpValue(MipsExpr->getSubExpr(), Fixups, STI); | |
| case MipsMCExpr::MEK_CALL_HI16: | |
| FixupKind = Mips::fixup_Mips_CALL_HI16; | |
| break; | |
| case MipsMCExpr::MEK_CALL_LO16: | |
| FixupKind = Mips::fixup_Mips_CALL_LO16; | |
| break; | |
| case MipsMCExpr::MEK_DTPREL_HI: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_TLS_DTPREL_HI16 | |
| : Mips::fixup_Mips_DTPREL_HI; | |
| break; | |
| case MipsMCExpr::MEK_DTPREL_LO: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_TLS_DTPREL_LO16 | |
| : Mips::fixup_Mips_DTPREL_LO; | |
| break; | |
| case MipsMCExpr::MEK_GOTTPREL: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_GOTTPREL | |
| : Mips::fixup_Mips_GOTTPREL; | |
| break; | |
| case MipsMCExpr::MEK_GOT: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_GOT16 | |
| : Mips::fixup_Mips_GOT; | |
| break; | |
| case MipsMCExpr::MEK_GOT_CALL: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_CALL16 | |
| : Mips::fixup_Mips_CALL16; | |
| break; | |
| case MipsMCExpr::MEK_GOT_DISP: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_GOT_DISP | |
| : Mips::fixup_Mips_GOT_DISP; | |
| break; | |
| case MipsMCExpr::MEK_GOT_HI16: | |
| FixupKind = Mips::fixup_Mips_GOT_HI16; | |
| break; | |
| case MipsMCExpr::MEK_GOT_LO16: | |
| FixupKind = Mips::fixup_Mips_GOT_LO16; | |
| break; | |
| case MipsMCExpr::MEK_GOT_PAGE: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_GOT_PAGE | |
| : Mips::fixup_Mips_GOT_PAGE; | |
| break; | |
| case MipsMCExpr::MEK_GOT_OFST: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_GOT_OFST | |
| : Mips::fixup_Mips_GOT_OFST; | |
| break; | |
| case MipsMCExpr::MEK_GPREL: | |
| FixupKind = Mips::fixup_Mips_GPREL16; | |
| break; | |
| case MipsMCExpr::MEK_LO: | |
| // Check for %lo(%neg(%gp_rel(X))) | |
| if (MipsExpr->isGpOff()) | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_GPOFF_LO | |
| : Mips::fixup_Mips_GPOFF_LO; | |
| else | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_LO16 | |
| : Mips::fixup_Mips_LO16; | |
| break; | |
| case MipsMCExpr::MEK_HIGHEST: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_HIGHEST | |
| : Mips::fixup_Mips_HIGHEST; | |
| break; | |
| case MipsMCExpr::MEK_HIGHER: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_HIGHER | |
| : Mips::fixup_Mips_HIGHER; | |
| break; | |
| case MipsMCExpr::MEK_HI: | |
| // Check for %hi(%neg(%gp_rel(X))) | |
| if (MipsExpr->isGpOff()) | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_GPOFF_HI | |
| : Mips::fixup_Mips_GPOFF_HI; | |
| else | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_HI16 | |
| : Mips::fixup_Mips_HI16; | |
| break; | |
| case MipsMCExpr::MEK_PCREL_HI16: | |
| FixupKind = Mips::fixup_MIPS_PCHI16; | |
| break; | |
| case MipsMCExpr::MEK_PCREL_LO16: | |
| FixupKind = Mips::fixup_MIPS_PCLO16; | |
| break; | |
| case MipsMCExpr::MEK_TLSGD: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_TLS_GD | |
| : Mips::fixup_Mips_TLSGD; | |
| break; | |
| case MipsMCExpr::MEK_TLSLDM: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_TLS_LDM | |
| : Mips::fixup_Mips_TLSLDM; | |
| break; | |
| case MipsMCExpr::MEK_TPREL_HI: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_TLS_TPREL_HI16 | |
| : Mips::fixup_Mips_TPREL_HI; | |
| break; | |
| case MipsMCExpr::MEK_TPREL_LO: | |
| FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_TLS_TPREL_LO16 | |
| : Mips::fixup_Mips_TPREL_LO; | |
| break; | |
| case MipsMCExpr::MEK_NEG: | |
| FixupKind = | |
| isMicroMips(STI) ? Mips::fixup_MICROMIPS_SUB : Mips::fixup_Mips_SUB; | |
| break; | |
| } | |
| Fixups.push_back(MCFixup::create(0, MipsExpr, MCFixupKind(FixupKind))); | |
| return 0; | |
| } | |
| if (Kind == MCExpr::SymbolRef) | |
| Ctx.reportError(Expr->getLoc(), "expected an immediate"); | |
| return 0; | |
| } | |
| /// getMachineOpValue - Return binary encoding of operand. If the machine | |
| /// operand requires relocation, record the relocation and return zero. | |
| unsigned MipsMCCodeEmitter:: | |
| getMachineOpValue(const MCInst &MI, const MCOperand &MO, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| if (MO.isReg()) { | |
| unsigned Reg = MO.getReg(); | |
| unsigned RegNo = Ctx.getRegisterInfo()->getEncodingValue(Reg); | |
| return RegNo; | |
| } else if (MO.isImm()) { | |
| return static_cast<unsigned>(MO.getImm()); | |
| } else if (MO.isDFPImm()) { | |
| return static_cast<unsigned>(bit_cast<double>(MO.getDFPImm())); | |
| } | |
| // MO must be an Expr. | |
| assert(MO.isExpr()); | |
| return getExprOpValue(MO.getExpr(),Fixups, STI); | |
| } | |
| /// Return binary encoding of memory related operand. | |
| /// If the offset operand requires relocation, record the relocation. | |
| template <unsigned ShiftAmount> | |
| unsigned MipsMCCodeEmitter::getMemEncoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Base register is encoded in bits 20-16, offset is encoded in bits 15-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, STI) | |
| << 16; | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI); | |
| // Apply the scale factor if there is one. | |
| OffBits >>= ShiftAmount; | |
| return (OffBits & 0xFFFF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm4(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Base register is encoded in bits 6-4, offset is encoded in bits 3-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), | |
| Fixups, STI) << 4; | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), | |
| Fixups, STI); | |
| return (OffBits & 0xF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm4Lsl1(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Base register is encoded in bits 6-4, offset is encoded in bits 3-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), | |
| Fixups, STI) << 4; | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), | |
| Fixups, STI) >> 1; | |
| return (OffBits & 0xF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm4Lsl2(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Base register is encoded in bits 6-4, offset is encoded in bits 3-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), | |
| Fixups, STI) << 4; | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), | |
| Fixups, STI) >> 2; | |
| return (OffBits & 0xF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMSPImm5Lsl2(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Register is encoded in bits 9-5, offset is encoded in bits 4-0. | |
| assert(MI.getOperand(OpNo).isReg() && | |
| (MI.getOperand(OpNo).getReg() == Mips::SP || | |
| MI.getOperand(OpNo).getReg() == Mips::SP_64) && | |
| "Unexpected base register!"); | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), | |
| Fixups, STI) >> 2; | |
| return OffBits & 0x1F; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMGPImm7Lsl2(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Register is encoded in bits 9-7, offset is encoded in bits 6-0. | |
| assert(MI.getOperand(OpNo).isReg() && | |
| MI.getOperand(OpNo).getReg() == Mips::GP && | |
| "Unexpected base register!"); | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), | |
| Fixups, STI) >> 2; | |
| return OffBits & 0x7F; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm9(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Base register is encoded in bits 20-16, offset is encoded in bits 8-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, | |
| STI) << 16; | |
| unsigned OffBits = | |
| getMachineOpValue(MI, MI.getOperand(OpNo + 1), Fixups, STI); | |
| return (OffBits & 0x1FF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm11(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Base register is encoded in bits 20-16, offset is encoded in bits 10-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, | |
| STI) << 16; | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI); | |
| return (OffBits & 0x07FF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm12(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // opNum can be invalid if instruction had reglist as operand. | |
| // MemOperand is always last operand of instruction (base + offset). | |
| switch (MI.getOpcode()) { | |
| default: | |
| break; | |
| case Mips::SWM32_MM: | |
| case Mips::LWM32_MM: | |
| OpNo = MI.getNumOperands() - 2; | |
| break; | |
| } | |
| // Base register is encoded in bits 20-16, offset is encoded in bits 11-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, STI) | |
| << 16; | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI); | |
| return (OffBits & 0x0FFF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm16(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // Base register is encoded in bits 20-16, offset is encoded in bits 15-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, | |
| STI) << 16; | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI); | |
| return (OffBits & 0xFFFF) | RegBits; | |
| } | |
| unsigned MipsMCCodeEmitter:: | |
| getMemEncodingMMImm4sp(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| // opNum can be invalid if instruction had reglist as operand | |
| // MemOperand is always last operand of instruction (base + offset) | |
| switch (MI.getOpcode()) { | |
| default: | |
| break; | |
| case Mips::SWM16_MM: | |
| case Mips::SWM16_MMR6: | |
| case Mips::LWM16_MM: | |
| case Mips::LWM16_MMR6: | |
| OpNo = MI.getNumOperands() - 2; | |
| break; | |
| } | |
| // Offset is encoded in bits 4-0. | |
| assert(MI.getOperand(OpNo).isReg()); | |
| // Base register is always SP - thus it is not encoded. | |
| assert(MI.getOperand(OpNo+1).isImm()); | |
| unsigned OffBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI); | |
| return ((OffBits >> 2) & 0x0F); | |
| } | |
| // FIXME: should be called getMSBEncoding | |
| // | |
| unsigned | |
| MipsMCCodeEmitter::getSizeInsEncoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| assert(MI.getOperand(OpNo-1).isImm()); | |
| assert(MI.getOperand(OpNo).isImm()); | |
| unsigned Position = getMachineOpValue(MI, MI.getOperand(OpNo-1), Fixups, STI); | |
| unsigned Size = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, STI); | |
| return Position + Size - 1; | |
| } | |
| template <unsigned Bits, int Offset> | |
| unsigned | |
| MipsMCCodeEmitter::getUImmWithOffsetEncoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| assert(MI.getOperand(OpNo).isImm()); | |
| unsigned Value = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, STI); | |
| Value -= Offset; | |
| return Value; | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getSimm19Lsl2Encoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| if (MO.isImm()) { | |
| // The immediate is encoded as 'immediate << 2'. | |
| unsigned Res = getMachineOpValue(MI, MO, Fixups, STI); | |
| assert((Res & 3) == 0); | |
| return Res >> 2; | |
| } | |
| assert(MO.isExpr() && | |
| "getSimm19Lsl2Encoding expects only expressions or an immediate"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Mips::Fixups FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_PC19_S2 | |
| : Mips::fixup_MIPS_PC19_S2; | |
| Fixups.push_back(MCFixup::create(0, Expr, MCFixupKind(FixupKind))); | |
| return 0; | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getSimm18Lsl3Encoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| if (MO.isImm()) { | |
| // The immediate is encoded as 'immediate << 3'. | |
| unsigned Res = getMachineOpValue(MI, MI.getOperand(OpNo), Fixups, STI); | |
| assert((Res & 7) == 0); | |
| return Res >> 3; | |
| } | |
| assert(MO.isExpr() && | |
| "getSimm18Lsl2Encoding expects only expressions or an immediate"); | |
| const MCExpr *Expr = MO.getExpr(); | |
| Mips::Fixups FixupKind = isMicroMips(STI) ? Mips::fixup_MICROMIPS_PC18_S3 | |
| : Mips::fixup_MIPS_PC18_S3; | |
| Fixups.push_back(MCFixup::create(0, Expr, MCFixupKind(FixupKind))); | |
| return 0; | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getUImm3Mod8Encoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| assert(MI.getOperand(OpNo).isImm()); | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| return MO.getImm() % 8; | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getUImm4AndValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| assert(MI.getOperand(OpNo).isImm()); | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| unsigned Value = MO.getImm(); | |
| switch (Value) { | |
| case 128: return 0x0; | |
| case 1: return 0x1; | |
| case 2: return 0x2; | |
| case 3: return 0x3; | |
| case 4: return 0x4; | |
| case 7: return 0x5; | |
| case 8: return 0x6; | |
| case 15: return 0x7; | |
| case 16: return 0x8; | |
| case 31: return 0x9; | |
| case 32: return 0xa; | |
| case 63: return 0xb; | |
| case 64: return 0xc; | |
| case 255: return 0xd; | |
| case 32768: return 0xe; | |
| case 65535: return 0xf; | |
| } | |
| llvm_unreachable("Unexpected value"); | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getRegisterListOpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| unsigned res = 0; | |
| // Register list operand is always first operand of instruction and it is | |
| // placed before memory operand (register + imm). | |
| for (unsigned I = OpNo, E = MI.getNumOperands() - 2; I < E; ++I) { | |
| unsigned Reg = MI.getOperand(I).getReg(); | |
| unsigned RegNo = Ctx.getRegisterInfo()->getEncodingValue(Reg); | |
| if (RegNo != 31) | |
| res++; | |
| else | |
| res |= 0x10; | |
| } | |
| return res; | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getRegisterListOpValue16(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| return (MI.getNumOperands() - 4); | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getMovePRegPairOpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| unsigned res = 0; | |
| if (MI.getOperand(0).getReg() == Mips::A1 && | |
| MI.getOperand(1).getReg() == Mips::A2) | |
| res = 0; | |
| else if (MI.getOperand(0).getReg() == Mips::A1 && | |
| MI.getOperand(1).getReg() == Mips::A3) | |
| res = 1; | |
| else if (MI.getOperand(0).getReg() == Mips::A2 && | |
| MI.getOperand(1).getReg() == Mips::A3) | |
| res = 2; | |
| else if (MI.getOperand(0).getReg() == Mips::A0 && | |
| MI.getOperand(1).getReg() == Mips::S5) | |
| res = 3; | |
| else if (MI.getOperand(0).getReg() == Mips::A0 && | |
| MI.getOperand(1).getReg() == Mips::S6) | |
| res = 4; | |
| else if (MI.getOperand(0).getReg() == Mips::A0 && | |
| MI.getOperand(1).getReg() == Mips::A1) | |
| res = 5; | |
| else if (MI.getOperand(0).getReg() == Mips::A0 && | |
| MI.getOperand(1).getReg() == Mips::A2) | |
| res = 6; | |
| else if (MI.getOperand(0).getReg() == Mips::A0 && | |
| MI.getOperand(1).getReg() == Mips::A3) | |
| res = 7; | |
| return res; | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getMovePRegSingleOpValue(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| assert(((OpNo == 2) || (OpNo == 3)) && | |
| "Unexpected OpNo for movep operand encoding!"); | |
| MCOperand Op = MI.getOperand(OpNo); | |
| assert(Op.isReg() && "Operand of movep is not a register!"); | |
| switch (Op.getReg()) { | |
| default: | |
| llvm_unreachable("Unknown register for movep!"); | |
| case Mips::ZERO: return 0; | |
| case Mips::S1: return 1; | |
| case Mips::V0: return 2; | |
| case Mips::V1: return 3; | |
| case Mips::S0: return 4; | |
| case Mips::S2: return 5; | |
| case Mips::S3: return 6; | |
| case Mips::S4: return 7; | |
| } | |
| } | |
| unsigned | |
| MipsMCCodeEmitter::getSimm23Lsl2Encoding(const MCInst &MI, unsigned OpNo, | |
| SmallVectorImpl<MCFixup> &Fixups, | |
| const MCSubtargetInfo &STI) const { | |
| const MCOperand &MO = MI.getOperand(OpNo); | |
| assert(MO.isImm() && "getSimm23Lsl2Encoding expects only an immediate"); | |
| // The immediate is encoded as 'immediate >> 2'. | |
| unsigned Res = static_cast<unsigned>(MO.getImm()); | |
| assert((Res & 3) == 0); | |
| return Res >> 2; | |
| } | |
| #include "MipsGenMCCodeEmitter.inc" |