RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity
88767efa6e
llvm-mirror/lib/Target/Hexagon/HexagonBitTracker.cpp
Mircea Trofin 611de20466 [NFC][MC] TargetRegisterInfo::getSubReg is a MCRegister. 
Typing the API appropriately.

Differential Revision: https://reviews.llvm.org/D92341
2020-12-02 15:46:38 -08:00

1290 lines
40 KiB
C++
Raw Blame History

//===- HexagonBitTracker.cpp ----------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "HexagonBitTracker.h"
#include "Hexagon.h"
#include "HexagonInstrInfo.h"
#include "HexagonRegisterInfo.h"
#include "HexagonSubtarget.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/IR/Argument.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Type.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <utility>
#include <vector>
using namespace llvm;
using BT = BitTracker;
HexagonEvaluator::HexagonEvaluator(const HexagonRegisterInfo &tri,
MachineRegisterInfo &mri,
const HexagonInstrInfo &tii,
MachineFunction &mf)
: MachineEvaluator(tri, mri), MF(mf), MFI(mf.getFrameInfo()), TII(tii) {
// Populate the VRX map (VR to extension-type).
// Go over all the formal parameters of the function. If a given parameter
// P is sign- or zero-extended, locate the virtual register holding that
// parameter and create an entry in the VRX map indicating the type of ex-
// tension (and the source type).
// This is a bit complicated to do accurately, since the memory layout in-
// formation is necessary to precisely determine whether an aggregate para-
// meter will be passed in a register or in memory. What is given in MRI
// is the association between the physical register that is live-in (i.e.
// holds an argument), and the virtual register that this value will be
// copied into. This, by itself, is not sufficient to map back the virtual
// register to a formal parameter from Function (since consecutive live-ins
// from MRI may not correspond to consecutive formal parameters from Func-
// tion). To avoid the complications with in-memory arguments, only consi-
// der the initial sequence of formal parameters that are known to be
// passed via registers.
unsigned InVirtReg, InPhysReg = 0;
for (const Argument &Arg : MF.getFunction().args()) {
Type *ATy = Arg.getType();
unsigned Width = 0;
if (ATy->isIntegerTy())
Width = ATy->getIntegerBitWidth();
else if (ATy->isPointerTy())
Width = 32;
// If pointer size is not set through target data, it will default to
// Module::AnyPointerSize.
if (Width == 0 || Width > 64)
break;
if (Arg.hasAttribute(Attribute::ByVal))
continue;
InPhysReg = getNextPhysReg(InPhysReg, Width);
if (!InPhysReg)
break;
InVirtReg = getVirtRegFor(InPhysReg);
if (!InVirtReg)
continue;
if (Arg.hasAttribute(Attribute::SExt))
VRX.insert(std::make_pair(InVirtReg, ExtType(ExtType::SExt, Width)));
else if (Arg.hasAttribute(Attribute::ZExt))
VRX.insert(std::make_pair(InVirtReg, ExtType(ExtType::ZExt, Width)));
}
}
BT::BitMask HexagonEvaluator::mask(Register Reg, unsigned Sub) const {
if (Sub == 0)
return MachineEvaluator::mask(Reg, 0);
const TargetRegisterClass &RC = *MRI.getRegClass(Reg);
unsigned ID = RC.getID();
uint16_t RW = getRegBitWidth(RegisterRef(Reg, Sub));
const auto &HRI = static_cast<const HexagonRegisterInfo&>(TRI);
bool IsSubLo = (Sub == HRI.getHexagonSubRegIndex(RC, Hexagon::ps_sub_lo));
switch (ID) {
case Hexagon::DoubleRegsRegClassID:
case Hexagon::HvxWRRegClassID:
case Hexagon::HvxVQRRegClassID:
return IsSubLo ? BT::BitMask(0, RW-1)
: BT::BitMask(RW, 2*RW-1);
default:
break;
}
#ifndef NDEBUG
dbgs() << printReg(Reg, &TRI, Sub) << " in reg class "
<< TRI.getRegClassName(&RC) << '\n';
#endif
llvm_unreachable("Unexpected register/subregister");
}
uint16_t HexagonEvaluator::getPhysRegBitWidth(MCRegister Reg) const {
using namespace Hexagon;
const auto &HST = MF.getSubtarget<HexagonSubtarget>();
if (HST.useHVXOps()) {
for (auto &RC : {HvxVRRegClass, HvxWRRegClass, HvxQRRegClass,
HvxVQRRegClass})
if (RC.contains(Reg))
return TRI.getRegSizeInBits(RC);
}
// Default treatment for other physical registers.
if (const TargetRegisterClass *RC = TRI.getMinimalPhysRegClass(Reg))
return TRI.getRegSizeInBits(*RC);
llvm_unreachable(
(Twine("Unhandled physical register") + TRI.getName(Reg)).str().c_str());
}
const TargetRegisterClass &HexagonEvaluator::composeWithSubRegIndex(
const TargetRegisterClass &RC, unsigned Idx) const {
if (Idx == 0)
return RC;
#ifndef NDEBUG
const auto &HRI = static_cast<const HexagonRegisterInfo&>(TRI);
bool IsSubLo = (Idx == HRI.getHexagonSubRegIndex(RC, Hexagon::ps_sub_lo));
bool IsSubHi = (Idx == HRI.getHexagonSubRegIndex(RC, Hexagon::ps_sub_hi));
assert(IsSubLo != IsSubHi && "Must refer to either low or high subreg");
#endif
switch (RC.getID()) {
case Hexagon::DoubleRegsRegClassID:
return Hexagon::IntRegsRegClass;
case Hexagon::HvxWRRegClassID:
return Hexagon::HvxVRRegClass;
case Hexagon::HvxVQRRegClassID:
return Hexagon::HvxWRRegClass;
default:
break;
}
#ifndef NDEBUG
dbgs() << "Reg class id: " << RC.getID() << " idx: " << Idx << '\n';
#endif
llvm_unreachable("Unimplemented combination of reg class/subreg idx");
}
namespace {
class RegisterRefs {
std::vector<BT::RegisterRef> Vector;
public:
RegisterRefs(const MachineInstr &MI) : Vector(MI.getNumOperands()) {
for (unsigned i = 0, n = Vector.size(); i < n; ++i) {
const MachineOperand &MO = MI.getOperand(i);
if (MO.isReg())
Vector[i] = BT::RegisterRef(MO);
// For indices that don't correspond to registers, the entry will
// remain constructed via the default constructor.
}
}
size_t size() const { return Vector.size(); }
const BT::RegisterRef &operator[](unsigned n) const {
// The main purpose of this operator is to assert with bad argument.
assert(n < Vector.size());
return Vector[n];
}
};
} // end anonymous namespace
bool HexagonEvaluator::evaluate(const MachineInstr &MI,
const CellMapType &Inputs,
CellMapType &Outputs) const {
using namespace Hexagon;
unsigned NumDefs = 0;
// Sanity verification: there should not be any defs with subregisters.
for (const MachineOperand &MO : MI.operands()) {
if (!MO.isReg() || !MO.isDef())
continue;
NumDefs++;
assert(MO.getSubReg() == 0);
}
if (NumDefs == 0)
return false;
unsigned Opc = MI.getOpcode();
if (MI.mayLoad()) {
switch (Opc) {
// These instructions may be marked as mayLoad, but they are generating
// immediate values, so skip them.
case CONST32:
case CONST64:
break;
default:
return evaluateLoad(MI, Inputs, Outputs);
}
}
// Check COPY instructions that copy formal parameters into virtual
// registers. Such parameters can be sign- or zero-extended at the
// call site, and we should take advantage of this knowledge. The MRI
// keeps a list of pairs of live-in physical and virtual registers,
// which provides information about which virtual registers will hold
// the argument values. The function will still contain instructions
// defining those virtual registers, and in practice those are COPY
// instructions from a physical to a virtual register. In such cases,
// applying the argument extension to the virtual register can be seen
// as simply mirroring the extension that had already been applied to
// the physical register at the call site. If the defining instruction
// was not a COPY, it would not be clear how to mirror that extension
// on the callee's side. For that reason, only check COPY instructions
// for potential extensions.
if (MI.isCopy()) {
if (evaluateFormalCopy(MI, Inputs, Outputs))
return true;
}
// Beyond this point, if any operand is a global, skip that instruction.
// The reason is that certain instructions that can take an immediate
// operand can also have a global symbol in that operand. To avoid
// checking what kind of operand a given instruction has individually
// for each instruction, do it here. Global symbols as operands gene-
// rally do not provide any useful information.
for (const MachineOperand &MO : MI.operands()) {
if (MO.isGlobal() || MO.isBlockAddress() || MO.isSymbol() || MO.isJTI() ||
MO.isCPI())
return false;
}
RegisterRefs Reg(MI);
#define op(i) MI.getOperand(i)
#define rc(i) RegisterCell::ref(getCell(Reg[i], Inputs))
#define im(i) MI.getOperand(i).getImm()
// If the instruction has no register operands, skip it.
if (Reg.size() == 0)
return false;
// Record result for register in operand 0.
auto rr0 = [this,Reg] (const BT::RegisterCell &Val, CellMapType &Outputs)
-> bool {
putCell(Reg[0], Val, Outputs);
return true;
};
// Get the cell corresponding to the N-th operand.
auto cop = [this, &Reg, &MI, &Inputs](unsigned N,
uint16_t W) -> BT::RegisterCell {
const MachineOperand &Op = MI.getOperand(N);
if (Op.isImm())
return eIMM(Op.getImm(), W);
if (!Op.isReg())
return RegisterCell::self(0, W);
assert(getRegBitWidth(Reg[N]) == W && "Register width mismatch");
return rc(N);
};
// Extract RW low bits of the cell.
auto lo = [this] (const BT::RegisterCell &RC, uint16_t RW)
-> BT::RegisterCell {
assert(RW <= RC.width());
return eXTR(RC, 0, RW);
};
// Extract RW high bits of the cell.
auto hi = [this] (const BT::RegisterCell &RC, uint16_t RW)
-> BT::RegisterCell {
uint16_t W = RC.width();
assert(RW <= W);
return eXTR(RC, W-RW, W);
};
// Extract N-th halfword (counting from the least significant position).
auto half = [this] (const BT::RegisterCell &RC, unsigned N)
-> BT::RegisterCell {
assert(N*16+16 <= RC.width());
return eXTR(RC, N*16, N*16+16);
};
// Shuffle bits (pick even/odd from cells and merge into result).
auto shuffle = [this] (const BT::RegisterCell &Rs, const BT::RegisterCell &Rt,
uint16_t BW, bool Odd) -> BT::RegisterCell {
uint16_t I = Odd, Ws = Rs.width();
assert(Ws == Rt.width());
RegisterCell RC = eXTR(Rt, I*BW, I*BW+BW).cat(eXTR(Rs, I*BW, I*BW+BW));
I += 2;
while (I*BW < Ws) {
RC.cat(eXTR(Rt, I*BW, I*BW+BW)).cat(eXTR(Rs, I*BW, I*BW+BW));
I += 2;
}
return RC;
};
// The bitwidth of the 0th operand. In most (if not all) of the
// instructions below, the 0th operand is the defined register.
// Pre-compute the bitwidth here, because it is needed in many cases
// cases below.
uint16_t W0 = (Reg[0].Reg != 0) ? getRegBitWidth(Reg[0]) : 0;
// Register id of the 0th operand. It can be 0.
unsigned Reg0 = Reg[0].Reg;
switch (Opc) {
// Transfer immediate:
case A2_tfrsi:
case A2_tfrpi:
case CONST32:
case CONST64:
return rr0(eIMM(im(1), W0), Outputs);
case PS_false:
return rr0(RegisterCell(W0).fill(0, W0, BT::BitValue::Zero), Outputs);
case PS_true:
return rr0(RegisterCell(W0).fill(0, W0, BT::BitValue::One), Outputs);
case PS_fi: {
int FI = op(1).getIndex();
int Off = op(2).getImm();
unsigned A = MFI.getObjectAlign(FI).value() + std::abs(Off);
unsigned L = countTrailingZeros(A);
RegisterCell RC = RegisterCell::self(Reg[0].Reg, W0);
RC.fill(0, L, BT::BitValue::Zero);
return rr0(RC, Outputs);
}
// Transfer register:
case A2_tfr:
case A2_tfrp:
case C2_pxfer_map:
return rr0(rc(1), Outputs);
case C2_tfrpr: {
uint16_t RW = W0;
uint16_t PW = 8; // XXX Pred size: getRegBitWidth(Reg[1]);
assert(PW <= RW);
RegisterCell PC = eXTR(rc(1), 0, PW);
RegisterCell RC = RegisterCell(RW).insert(PC, BT::BitMask(0, PW-1));
RC.fill(PW, RW, BT::BitValue::Zero);
return rr0(RC, Outputs);
}
case C2_tfrrp: {
uint16_t RW = W0;
uint16_t PW = 8; // XXX Pred size: getRegBitWidth(Reg[1]);
RegisterCell RC = RegisterCell::self(Reg[0].Reg, RW);
RC.fill(PW, RW, BT::BitValue::Zero);
return rr0(eINS(RC, eXTR(rc(1), 0, PW), 0), Outputs);
}
// Arithmetic:
case A2_abs:
case A2_absp:
// TODO
break;
case A2_addsp: {
uint16_t W1 = getRegBitWidth(Reg[1]);
assert(W0 == 64 && W1 == 32);
RegisterCell CW = RegisterCell(W0).insert(rc(1), BT::BitMask(0, W1-1));
RegisterCell RC = eADD(eSXT(CW, W1), rc(2));
return rr0(RC, Outputs);
}
case A2_add:
case A2_addp:
return rr0(eADD(rc(1), rc(2)), Outputs);
case A2_addi:
return rr0(eADD(rc(1), eIMM(im(2), W0)), Outputs);
case S4_addi_asl_ri: {
RegisterCell RC = eADD(eIMM(im(1), W0), eASL(rc(2), im(3)));
return rr0(RC, Outputs);
}
case S4_addi_lsr_ri: {
RegisterCell RC = eADD(eIMM(im(1), W0), eLSR(rc(2), im(3)));
return rr0(RC, Outputs);
}
case S4_addaddi: {
RegisterCell RC = eADD(rc(1), eADD(rc(2), eIMM(im(3), W0)));
return rr0(RC, Outputs);
}
case M4_mpyri_addi: {
RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
RegisterCell RC = eADD(eIMM(im(1), W0), lo(M, W0));
return rr0(RC, Outputs);
}
case M4_mpyrr_addi: {
RegisterCell M = eMLS(rc(2), rc(3));
RegisterCell RC = eADD(eIMM(im(1), W0), lo(M, W0));
return rr0(RC, Outputs);
}
case M4_mpyri_addr_u2: {
RegisterCell M = eMLS(eIMM(im(2), W0), rc(3));
RegisterCell RC = eADD(rc(1), lo(M, W0));
return rr0(RC, Outputs);
}
case M4_mpyri_addr: {
RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
RegisterCell RC = eADD(rc(1), lo(M, W0));
return rr0(RC, Outputs);
}
case M4_mpyrr_addr: {
RegisterCell M = eMLS(rc(2), rc(3));
RegisterCell RC = eADD(rc(1), lo(M, W0));
return rr0(RC, Outputs);
}
case S4_subaddi: {
RegisterCell RC = eADD(rc(1), eSUB(eIMM(im(2), W0), rc(3)));
return rr0(RC, Outputs);
}
case M2_accii: {
RegisterCell RC = eADD(rc(1), eADD(rc(2), eIMM(im(3), W0)));
return rr0(RC, Outputs);
}
case M2_acci: {
RegisterCell RC = eADD(rc(1), eADD(rc(2), rc(3)));
return rr0(RC, Outputs);
}
case M2_subacc: {
RegisterCell RC = eADD(rc(1), eSUB(rc(2), rc(3)));
return rr0(RC, Outputs);
}
case S2_addasl_rrri: {
RegisterCell RC = eADD(rc(1), eASL(rc(2), im(3)));
return rr0(RC, Outputs);
}
case C4_addipc: {
RegisterCell RPC = RegisterCell::self(Reg[0].Reg, W0);
RPC.fill(0, 2, BT::BitValue::Zero);
return rr0(eADD(RPC, eIMM(im(2), W0)), Outputs);
}
case A2_sub:
case A2_subp:
return rr0(eSUB(rc(1), rc(2)), Outputs);
case A2_subri:
return rr0(eSUB(eIMM(im(1), W0), rc(2)), Outputs);
case S4_subi_asl_ri: {
RegisterCell RC = eSUB(eIMM(im(1), W0), eASL(rc(2), im(3)));
return rr0(RC, Outputs);
}
case S4_subi_lsr_ri: {
RegisterCell RC = eSUB(eIMM(im(1), W0), eLSR(rc(2), im(3)));
return rr0(RC, Outputs);
}
case M2_naccii: {
RegisterCell RC = eSUB(rc(1), eADD(rc(2), eIMM(im(3), W0)));
return rr0(RC, Outputs);
}
case M2_nacci: {
RegisterCell RC = eSUB(rc(1), eADD(rc(2), rc(3)));
return rr0(RC, Outputs);
}
// 32-bit negation is done by "Rd = A2_subri 0, Rs"
case A2_negp:
return rr0(eSUB(eIMM(0, W0), rc(1)), Outputs);
case M2_mpy_up: {
RegisterCell M = eMLS(rc(1), rc(2));
return rr0(hi(M, W0), Outputs);
}
case M2_dpmpyss_s0:
return rr0(eMLS(rc(1), rc(2)), Outputs);
case M2_dpmpyss_acc_s0:
return rr0(eADD(rc(1), eMLS(rc(2), rc(3))), Outputs);
case M2_dpmpyss_nac_s0:
return rr0(eSUB(rc(1), eMLS(rc(2), rc(3))), Outputs);
case M2_mpyi: {
RegisterCell M = eMLS(rc(1), rc(2));
return rr0(lo(M, W0), Outputs);
}
case M2_macsip: {
RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
RegisterCell RC = eADD(rc(1), lo(M, W0));
return rr0(RC, Outputs);
}
case M2_macsin: {
RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
RegisterCell RC = eSUB(rc(1), lo(M, W0));
return rr0(RC, Outputs);
}
case M2_maci: {
RegisterCell M = eMLS(rc(2), rc(3));
RegisterCell RC = eADD(rc(1), lo(M, W0));
return rr0(RC, Outputs);
}
case M2_mpysmi: {
RegisterCell M = eMLS(rc(1), eIMM(im(2), W0));
return rr0(lo(M, 32), Outputs);
}
case M2_mpysin: {
RegisterCell M = eMLS(rc(1), eIMM(-im(2), W0));
return rr0(lo(M, 32), Outputs);
}
case M2_mpysip: {
RegisterCell M = eMLS(rc(1), eIMM(im(2), W0));
return rr0(lo(M, 32), Outputs);
}
case M2_mpyu_up: {
RegisterCell M = eMLU(rc(1), rc(2));
return rr0(hi(M, W0), Outputs);
}
case M2_dpmpyuu_s0:
return rr0(eMLU(rc(1), rc(2)), Outputs);
case M2_dpmpyuu_acc_s0:
return rr0(eADD(rc(1), eMLU(rc(2), rc(3))), Outputs);
case M2_dpmpyuu_nac_s0:
return rr0(eSUB(rc(1), eMLU(rc(2), rc(3))), Outputs);
//case M2_mpysu_up:
// Logical/bitwise:
case A2_andir:
return rr0(eAND(rc(1), eIMM(im(2), W0)), Outputs);
case A2_and:
case A2_andp:
return rr0(eAND(rc(1), rc(2)), Outputs);
case A4_andn:
case A4_andnp:
return rr0(eAND(rc(1), eNOT(rc(2))), Outputs);
case S4_andi_asl_ri: {
RegisterCell RC = eAND(eIMM(im(1), W0), eASL(rc(2), im(3)));
return rr0(RC, Outputs);
}
case S4_andi_lsr_ri: {
RegisterCell RC = eAND(eIMM(im(1), W0), eLSR(rc(2), im(3)));
return rr0(RC, Outputs);
}
case M4_and_and:
return rr0(eAND(rc(1), eAND(rc(2), rc(3))), Outputs);
case M4_and_andn:
return rr0(eAND(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
case M4_and_or:
return rr0(eAND(rc(1), eORL(rc(2), rc(3))), Outputs);
case M4_and_xor:
return rr0(eAND(rc(1), eXOR(rc(2), rc(3))), Outputs);
case A2_orir:
return rr0(eORL(rc(1), eIMM(im(2), W0)), Outputs);
case A2_or:
case A2_orp:
return rr0(eORL(rc(1), rc(2)), Outputs);
case A4_orn:
case A4_ornp:
return rr0(eORL(rc(1), eNOT(rc(2))), Outputs);
case S4_ori_asl_ri: {
RegisterCell RC = eORL(eIMM(im(1), W0), eASL(rc(2), im(3)));
return rr0(RC, Outputs);
}
case S4_ori_lsr_ri: {
RegisterCell RC = eORL(eIMM(im(1), W0), eLSR(rc(2), im(3)));
return rr0(RC, Outputs);
}
case M4_or_and:
return rr0(eORL(rc(1), eAND(rc(2), rc(3))), Outputs);
case M4_or_andn:
return rr0(eORL(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
case S4_or_andi:
case S4_or_andix: {
RegisterCell RC = eORL(rc(1), eAND(rc(2), eIMM(im(3), W0)));
return rr0(RC, Outputs);
}
case S4_or_ori: {
RegisterCell RC = eORL(rc(1), eORL(rc(2), eIMM(im(3), W0)));
return rr0(RC, Outputs);
}
case M4_or_or:
return rr0(eORL(rc(1), eORL(rc(2), rc(3))), Outputs);
case M4_or_xor:
return rr0(eORL(rc(1), eXOR(rc(2), rc(3))), Outputs);
case A2_xor:
case A2_xorp:
return rr0(eXOR(rc(1), rc(2)), Outputs);
case M4_xor_and:
return rr0(eXOR(rc(1), eAND(rc(2), rc(3))), Outputs);
case M4_xor_andn:
return rr0(eXOR(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
case M4_xor_or:
return rr0(eXOR(rc(1), eORL(rc(2), rc(3))), Outputs);
case M4_xor_xacc:
return rr0(eXOR(rc(1), eXOR(rc(2), rc(3))), Outputs);
case A2_not:
case A2_notp:
return rr0(eNOT(rc(1)), Outputs);
case S2_asl_i_r:
case S2_asl_i_p:
return rr0(eASL(rc(1), im(2)), Outputs);
case A2_aslh:
return rr0(eASL(rc(1), 16), Outputs);
case S2_asl_i_r_acc:
case S2_asl_i_p_acc:
return rr0(eADD(rc(1), eASL(rc(2), im(3))), Outputs);
case S2_asl_i_r_nac:
case S2_asl_i_p_nac:
return rr0(eSUB(rc(1), eASL(rc(2), im(3))), Outputs);
case S2_asl_i_r_and:
case S2_asl_i_p_and:
return rr0(eAND(rc(1), eASL(rc(2), im(3))), Outputs);
case S2_asl_i_r_or:
case S2_asl_i_p_or:
return rr0(eORL(rc(1), eASL(rc(2), im(3))), Outputs);
case S2_asl_i_r_xacc:
case S2_asl_i_p_xacc:
return rr0(eXOR(rc(1), eASL(rc(2), im(3))), Outputs);
case S2_asl_i_vh:
case S2_asl_i_vw:
// TODO
break;
case S2_asr_i_r:
case S2_asr_i_p:
return rr0(eASR(rc(1), im(2)), Outputs);
case A2_asrh:
return rr0(eASR(rc(1), 16), Outputs);
case S2_asr_i_r_acc:
case S2_asr_i_p_acc:
return rr0(eADD(rc(1), eASR(rc(2), im(3))), Outputs);
case S2_asr_i_r_nac:
case S2_asr_i_p_nac:
return rr0(eSUB(rc(1), eASR(rc(2), im(3))), Outputs);
case S2_asr_i_r_and:
case S2_asr_i_p_and:
return rr0(eAND(rc(1), eASR(rc(2), im(3))), Outputs);
case S2_asr_i_r_or:
case S2_asr_i_p_or:
return rr0(eORL(rc(1), eASR(rc(2), im(3))), Outputs);
case S2_asr_i_r_rnd: {
// The input is first sign-extended to 64 bits, then the output
// is truncated back to 32 bits.
assert(W0 == 32);
RegisterCell XC = eSXT(rc(1).cat(eIMM(0, W0)), W0);
RegisterCell RC = eASR(eADD(eASR(XC, im(2)), eIMM(1, 2*W0)), 1);
return rr0(eXTR(RC, 0, W0), Outputs);
}
case S2_asr_i_r_rnd_goodsyntax: {
int64_t S = im(2);
if (S == 0)
return rr0(rc(1), Outputs);
// Result: S2_asr_i_r_rnd Rs, u5-1
RegisterCell XC = eSXT(rc(1).cat(eIMM(0, W0)), W0);
RegisterCell RC = eLSR(eADD(eASR(XC, S-1), eIMM(1, 2*W0)), 1);
return rr0(eXTR(RC, 0, W0), Outputs);
}
case S2_asr_r_vh:
case S2_asr_i_vw:
case S2_asr_i_svw_trun:
// TODO
break;
case S2_lsr_i_r:
case S2_lsr_i_p:
return rr0(eLSR(rc(1), im(2)), Outputs);
case S2_lsr_i_r_acc:
case S2_lsr_i_p_acc:
return rr0(eADD(rc(1), eLSR(rc(2), im(3))), Outputs);
case S2_lsr_i_r_nac:
case S2_lsr_i_p_nac:
return rr0(eSUB(rc(1), eLSR(rc(2), im(3))), Outputs);
case S2_lsr_i_r_and:
case S2_lsr_i_p_and:
return rr0(eAND(rc(1), eLSR(rc(2), im(3))), Outputs);
case S2_lsr_i_r_or:
case S2_lsr_i_p_or:
return rr0(eORL(rc(1), eLSR(rc(2), im(3))), Outputs);
case S2_lsr_i_r_xacc:
case S2_lsr_i_p_xacc:
return rr0(eXOR(rc(1), eLSR(rc(2), im(3))), Outputs);
case S2_clrbit_i: {
RegisterCell RC = rc(1);
RC[im(2)] = BT::BitValue::Zero;
return rr0(RC, Outputs);
}
case S2_setbit_i: {
RegisterCell RC = rc(1);
RC[im(2)] = BT::BitValue::One;
return rr0(RC, Outputs);
}
case S2_togglebit_i: {
RegisterCell RC = rc(1);
uint16_t BX = im(2);
RC[BX] = RC[BX].is(0) ? BT::BitValue::One
: RC[BX].is(1) ? BT::BitValue::Zero
: BT::BitValue::self();
return rr0(RC, Outputs);
}
case A4_bitspliti: {
uint16_t W1 = getRegBitWidth(Reg[1]);
uint16_t BX = im(2);
// Res.uw[1] = Rs[bx+1:], Res.uw[0] = Rs[0:bx]
const BT::BitValue Zero = BT::BitValue::Zero;
RegisterCell RZ = RegisterCell(W0).fill(BX, W1, Zero)
.fill(W1+(W1-BX), W0, Zero);
RegisterCell BF1 = eXTR(rc(1), 0, BX), BF2 = eXTR(rc(1), BX, W1);
RegisterCell RC = eINS(eINS(RZ, BF1, 0), BF2, W1);
return rr0(RC, Outputs);
}
case S4_extract:
case S4_extractp:
case S2_extractu:
case S2_extractup: {
uint16_t Wd = im(2), Of = im(3);
assert(Wd <= W0);
if (Wd == 0)
return rr0(eIMM(0, W0), Outputs);
// If the width extends beyond the register size, pad the register
// with 0 bits.
RegisterCell Pad = (Wd+Of > W0) ? rc(1).cat(eIMM(0, Wd+Of-W0)) : rc(1);
RegisterCell Ext = eXTR(Pad, Of, Wd+Of);
// Ext is short, need to extend it with 0s or sign bit.
RegisterCell RC = RegisterCell(W0).insert(Ext, BT::BitMask(0, Wd-1));
if (Opc == S2_extractu || Opc == S2_extractup)
return rr0(eZXT(RC, Wd), Outputs);
return rr0(eSXT(RC, Wd), Outputs);
}
case S2_insert:
case S2_insertp: {
uint16_t Wd = im(3), Of = im(4);
assert(Wd < W0 && Of < W0);
// If Wd+Of exceeds W0, the inserted bits are truncated.
if (Wd+Of > W0)
Wd = W0-Of;
if (Wd == 0)
return rr0(rc(1), Outputs);
return rr0(eINS(rc(1), eXTR(rc(2), 0, Wd), Of), Outputs);
}
// Bit permutations:
case A2_combineii:
case A4_combineii:
case A4_combineir:
case A4_combineri:
case A2_combinew:
case V6_vcombine:
assert(W0 % 2 == 0);
return rr0(cop(2, W0/2).cat(cop(1, W0/2)), Outputs);
case A2_combine_ll:
case A2_combine_lh:
case A2_combine_hl:
case A2_combine_hh: {
assert(W0 == 32);
assert(getRegBitWidth(Reg[1]) == 32 && getRegBitWidth(Reg[2]) == 32);
// Low half in the output is 0 for _ll and _hl, 1 otherwise:
unsigned LoH = !(Opc == A2_combine_ll || Opc == A2_combine_hl);
// High half in the output is 0 for _ll and _lh, 1 otherwise:
unsigned HiH = !(Opc == A2_combine_ll || Opc == A2_combine_lh);
RegisterCell R1 = rc(1);
RegisterCell R2 = rc(2);
RegisterCell RC = half(R2, LoH).cat(half(R1, HiH));
return rr0(RC, Outputs);
}
case S2_packhl: {
assert(W0 == 64);
assert(getRegBitWidth(Reg[1]) == 32 && getRegBitWidth(Reg[2]) == 32);
RegisterCell R1 = rc(1);
RegisterCell R2 = rc(2);
RegisterCell RC = half(R2, 0).cat(half(R1, 0)).cat(half(R2, 1))
.cat(half(R1, 1));
return rr0(RC, Outputs);
}
case S2_shuffeb: {
RegisterCell RC = shuffle(rc(1), rc(2), 8, false);
return rr0(RC, Outputs);
}
case S2_shuffeh: {
RegisterCell RC = shuffle(rc(1), rc(2), 16, false);
return rr0(RC, Outputs);
}
case S2_shuffob: {
RegisterCell RC = shuffle(rc(1), rc(2), 8, true);
return rr0(RC, Outputs);
}
case S2_shuffoh: {
RegisterCell RC = shuffle(rc(1), rc(2), 16, true);
return rr0(RC, Outputs);
}
case C2_mask: {
uint16_t WR = W0;
uint16_t WP = 8; // XXX Pred size: getRegBitWidth(Reg[1]);
assert(WR == 64 && WP == 8);
RegisterCell R1 = rc(1);
RegisterCell RC(WR);
for (uint16_t i = 0; i < WP; ++i) {
const BT::BitValue &V = R1[i];
BT::BitValue F = (V.is(0) || V.is(1)) ? V : BT::BitValue::self();
RC.fill(i*8, i*8+8, F);
}
return rr0(RC, Outputs);
}
// Mux:
case C2_muxii:
case C2_muxir:
case C2_muxri:
case C2_mux: {
BT::BitValue PC0 = rc(1)[0];
RegisterCell R2 = cop(2, W0);
RegisterCell R3 = cop(3, W0);
if (PC0.is(0) || PC0.is(1))
return rr0(RegisterCell::ref(PC0 ? R2 : R3), Outputs);
R2.meet(R3, Reg[0].Reg);
return rr0(R2, Outputs);
}
case C2_vmux:
// TODO
break;
// Sign- and zero-extension:
case A2_sxtb:
return rr0(eSXT(rc(1), 8), Outputs);
case A2_sxth:
return rr0(eSXT(rc(1), 16), Outputs);
case A2_sxtw: {
uint16_t W1 = getRegBitWidth(Reg[1]);
assert(W0 == 64 && W1 == 32);
RegisterCell RC = eSXT(rc(1).cat(eIMM(0, W1)), W1);
return rr0(RC, Outputs);
}
case A2_zxtb:
return rr0(eZXT(rc(1), 8), Outputs);
case A2_zxth:
return rr0(eZXT(rc(1), 16), Outputs);
// Saturations
case A2_satb:
return rr0(eSXT(RegisterCell::self(0, W0).regify(Reg0), 8), Outputs);
case A2_sath:
return rr0(eSXT(RegisterCell::self(0, W0).regify(Reg0), 16), Outputs);
case A2_satub:
return rr0(eZXT(RegisterCell::self(0, W0).regify(Reg0), 8), Outputs);
case A2_satuh:
return rr0(eZXT(RegisterCell::self(0, W0).regify(Reg0), 16), Outputs);
// Bit count:
case S2_cl0:
case S2_cl0p:
// Always produce a 32-bit result.
return rr0(eCLB(rc(1), false/*bit*/, 32), Outputs);
case S2_cl1:
case S2_cl1p:
return rr0(eCLB(rc(1), true/*bit*/, 32), Outputs);
case S2_clb:
case S2_clbp: {
uint16_t W1 = getRegBitWidth(Reg[1]);
RegisterCell R1 = rc(1);
BT::BitValue TV = R1[W1-1];
if (TV.is(0) || TV.is(1))
return rr0(eCLB(R1, TV, 32), Outputs);
break;
}
case S2_ct0:
case S2_ct0p:
return rr0(eCTB(rc(1), false/*bit*/, 32), Outputs);
case S2_ct1:
case S2_ct1p:
return rr0(eCTB(rc(1), true/*bit*/, 32), Outputs);
case S5_popcountp:
// TODO
break;
case C2_all8: {
RegisterCell P1 = rc(1);
bool Has0 = false, All1 = true;
for (uint16_t i = 0; i < 8/*XXX*/; ++i) {
if (!P1[i].is(1))
All1 = false;
if (!P1[i].is(0))
continue;
Has0 = true;
break;
}
if (!Has0 && !All1)
break;
RegisterCell RC(W0);
RC.fill(0, W0, (All1 ? BT::BitValue::One : BT::BitValue::Zero));
return rr0(RC, Outputs);
}
case C2_any8: {
RegisterCell P1 = rc(1);
bool Has1 = false, All0 = true;
for (uint16_t i = 0; i < 8/*XXX*/; ++i) {
if (!P1[i].is(0))
All0 = false;
if (!P1[i].is(1))
continue;
Has1 = true;
break;
}
if (!Has1 && !All0)
break;
RegisterCell RC(W0);
RC.fill(0, W0, (Has1 ? BT::BitValue::One : BT::BitValue::Zero));
return rr0(RC, Outputs);
}
case C2_and:
return rr0(eAND(rc(1), rc(2)), Outputs);
case C2_andn:
return rr0(eAND(rc(1), eNOT(rc(2))), Outputs);
case C2_not:
return rr0(eNOT(rc(1)), Outputs);
case C2_or:
return rr0(eORL(rc(1), rc(2)), Outputs);
case C2_orn:
return rr0(eORL(rc(1), eNOT(rc(2))), Outputs);
case C2_xor:
return rr0(eXOR(rc(1), rc(2)), Outputs);
case C4_and_and:
return rr0(eAND(rc(1), eAND(rc(2), rc(3))), Outputs);
case C4_and_andn:
return rr0(eAND(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
case C4_and_or:
return rr0(eAND(rc(1), eORL(rc(2), rc(3))), Outputs);
case C4_and_orn:
return rr0(eAND(rc(1), eORL(rc(2), eNOT(rc(3)))), Outputs);
case C4_or_and:
return rr0(eORL(rc(1), eAND(rc(2), rc(3))), Outputs);
case C4_or_andn:
return rr0(eORL(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
case C4_or_or:
return rr0(eORL(rc(1), eORL(rc(2), rc(3))), Outputs);
case C4_or_orn:
return rr0(eORL(rc(1), eORL(rc(2), eNOT(rc(3)))), Outputs);
case C2_bitsclr:
case C2_bitsclri:
case C2_bitsset:
case C4_nbitsclr:
case C4_nbitsclri:
case C4_nbitsset:
// TODO
break;
case S2_tstbit_i:
case S4_ntstbit_i: {
BT::BitValue V = rc(1)[im(2)];
if (V.is(0) || V.is(1)) {
// If instruction is S2_tstbit_i, test for 1, otherwise test for 0.
bool TV = (Opc == S2_tstbit_i);
BT::BitValue F = V.is(TV) ? BT::BitValue::One : BT::BitValue::Zero;
return rr0(RegisterCell(W0).fill(0, W0, F), Outputs);
}
break;
}
default:
// For instructions that define a single predicate registers, store
// the low 8 bits of the register only.
if (unsigned DefR = getUniqueDefVReg(MI)) {
if (MRI.getRegClass(DefR) == &Hexagon::PredRegsRegClass) {
BT::RegisterRef PD(DefR, 0);
uint16_t RW = getRegBitWidth(PD);
uint16_t PW = 8; // XXX Pred size: getRegBitWidth(Reg[1]);
RegisterCell RC = RegisterCell::self(DefR, RW);
RC.fill(PW, RW, BT::BitValue::Zero);
putCell(PD, RC, Outputs);
return true;
}
}
return MachineEvaluator::evaluate(MI, Inputs, Outputs);
}
#undef im
#undef rc
#undef op
return false;
}
bool HexagonEvaluator::evaluate(const MachineInstr &BI,
const CellMapType &Inputs,
BranchTargetList &Targets,
bool &FallsThru) const {
// We need to evaluate one branch at a time. TII::analyzeBranch checks
// all the branches in a basic block at once, so we cannot use it.
unsigned Opc = BI.getOpcode();
bool SimpleBranch = false;
bool Negated = false;
switch (Opc) {
case Hexagon::J2_jumpf:
case Hexagon::J2_jumpfpt:
case Hexagon::J2_jumpfnew:
case Hexagon::J2_jumpfnewpt:
Negated = true;
LLVM_FALLTHROUGH;
case Hexagon::J2_jumpt:
case Hexagon::J2_jumptpt:
case Hexagon::J2_jumptnew:
case Hexagon::J2_jumptnewpt:
// Simple branch: if([!]Pn) jump ...
// i.e. Op0 = predicate, Op1 = branch target.
SimpleBranch = true;
break;
case Hexagon::J2_jump:
Targets.insert(BI.getOperand(0).getMBB());
FallsThru = false;
return true;
default:
// If the branch is of unknown type, assume that all successors are
// executable.
return false;
}
if (!SimpleBranch)
return false;
// BI is a conditional branch if we got here.
RegisterRef PR = BI.getOperand(0);
RegisterCell PC = getCell(PR, Inputs);
const BT::BitValue &Test = PC[0];
// If the condition is neither true nor false, then it's unknown.
if (!Test.is(0) && !Test.is(1))
return false;
// "Test.is(!Negated)" means "branch condition is true".
if (!Test.is(!Negated)) {
// Condition known to be false.
FallsThru = true;
return true;
}
Targets.insert(BI.getOperand(1).getMBB());
FallsThru = false;
return true;
}
unsigned HexagonEvaluator::getUniqueDefVReg(const MachineInstr &MI) const {
unsigned DefReg = 0;
for (const MachineOperand &Op : MI.operands()) {
if (!Op.isReg() || !Op.isDef())
continue;
Register R = Op.getReg();
if (!R.isVirtual())
continue;
if (DefReg != 0)
return 0;
DefReg = R;
}
return DefReg;
}
bool HexagonEvaluator::evaluateLoad(const MachineInstr &MI,
const CellMapType &Inputs,
CellMapType &Outputs) const {
using namespace Hexagon;
if (TII.isPredicated(MI))
return false;
assert(MI.mayLoad() && "A load that mayn't?");
unsigned Opc = MI.getOpcode();
uint16_t BitNum;
bool SignEx;
switch (Opc) {
default:
return false;
#if 0
// memb_fifo
case L2_loadalignb_pbr:
case L2_loadalignb_pcr:
case L2_loadalignb_pi:
// memh_fifo
case L2_loadalignh_pbr:
case L2_loadalignh_pcr:
case L2_loadalignh_pi:
// membh
case L2_loadbsw2_pbr:
case L2_loadbsw2_pci:
case L2_loadbsw2_pcr:
case L2_loadbsw2_pi:
case L2_loadbsw4_pbr:
case L2_loadbsw4_pci:
case L2_loadbsw4_pcr:
case L2_loadbsw4_pi:
// memubh
case L2_loadbzw2_pbr:
case L2_loadbzw2_pci:
case L2_loadbzw2_pcr:
case L2_loadbzw2_pi:
case L2_loadbzw4_pbr:
case L2_loadbzw4_pci:
case L2_loadbzw4_pcr:
case L2_loadbzw4_pi:
#endif
case L2_loadrbgp:
case L2_loadrb_io:
case L2_loadrb_pbr:
case L2_loadrb_pci:
case L2_loadrb_pcr:
case L2_loadrb_pi:
case PS_loadrbabs:
case L4_loadrb_ap:
case L4_loadrb_rr:
case L4_loadrb_ur:
BitNum = 8;
SignEx = true;
break;
case L2_loadrubgp:
case L2_loadrub_io:
case L2_loadrub_pbr:
case L2_loadrub_pci:
case L2_loadrub_pcr:
case L2_loadrub_pi:
case PS_loadrubabs:
case L4_loadrub_ap:
case L4_loadrub_rr:
case L4_loadrub_ur:
BitNum = 8;
SignEx = false;
break;
case L2_loadrhgp:
case L2_loadrh_io:
case L2_loadrh_pbr:
case L2_loadrh_pci:
case L2_loadrh_pcr:
case L2_loadrh_pi:
case PS_loadrhabs:
case L4_loadrh_ap:
case L4_loadrh_rr:
case L4_loadrh_ur:
BitNum = 16;
SignEx = true;
break;
case L2_loadruhgp:
case L2_loadruh_io:
case L2_loadruh_pbr:
case L2_loadruh_pci:
case L2_loadruh_pcr:
case L2_loadruh_pi:
case L4_loadruh_rr:
case PS_loadruhabs:
case L4_loadruh_ap:
case L4_loadruh_ur:
BitNum = 16;
SignEx = false;
break;
case L2_loadrigp:
case L2_loadri_io:
case L2_loadri_pbr:
case L2_loadri_pci:
case L2_loadri_pcr:
case L2_loadri_pi:
case L2_loadw_locked:
case PS_loadriabs:
case L4_loadri_ap:
case L4_loadri_rr:
case L4_loadri_ur:
case LDriw_pred:
BitNum = 32;
SignEx = true;
break;
case L2_loadrdgp:
case L2_loadrd_io:
case L2_loadrd_pbr:
case L2_loadrd_pci:
case L2_loadrd_pcr:
case L2_loadrd_pi:
case L4_loadd_locked:
case PS_loadrdabs:
case L4_loadrd_ap:
case L4_loadrd_rr:
case L4_loadrd_ur:
BitNum = 64;
SignEx = true;
break;
}
const MachineOperand &MD = MI.getOperand(0);
assert(MD.isReg() && MD.isDef());
RegisterRef RD = MD;
uint16_t W = getRegBitWidth(RD);
assert(W >= BitNum && BitNum > 0);
RegisterCell Res(W);
for (uint16_t i = 0; i < BitNum; ++i)
Res[i] = BT::BitValue::self(BT::BitRef(RD.Reg, i));
if (SignEx) {
const BT::BitValue &Sign = Res[BitNum-1];
for (uint16_t i = BitNum; i < W; ++i)
Res[i] = BT::BitValue::ref(Sign);
} else {
for (uint16_t i = BitNum; i < W; ++i)
Res[i] = BT::BitValue::Zero;
}
putCell(RD, Res, Outputs);
return true;
}
bool HexagonEvaluator::evaluateFormalCopy(const MachineInstr &MI,
const CellMapType &Inputs,
CellMapType &Outputs) const {
// If MI defines a formal parameter, but is not a copy (loads are handled
// in evaluateLoad), then it's not clear what to do.
assert(MI.isCopy());
RegisterRef RD = MI.getOperand(0);
RegisterRef RS = MI.getOperand(1);
assert(RD.Sub == 0);
if (!Register::isPhysicalRegister(RS.Reg))
return false;
RegExtMap::const_iterator F = VRX.find(RD.Reg);
if (F == VRX.end())
return false;
uint16_t EW = F->second.Width;
// Store RD's cell into the map. This will associate the cell with a virtual
// register, and make zero-/sign-extends possible (otherwise we would be ex-
// tending "self" bit values, which will have no effect, since "self" values
// cannot be references to anything).
putCell(RD, getCell(RS, Inputs), Outputs);
RegisterCell Res;
// Read RD's cell from the outputs instead of RS's cell from the inputs:
if (F->second.Type == ExtType::SExt)
Res = eSXT(getCell(RD, Outputs), EW);
else if (F->second.Type == ExtType::ZExt)
Res = eZXT(getCell(RD, Outputs), EW);
putCell(RD, Res, Outputs);
return true;
}
unsigned HexagonEvaluator::getNextPhysReg(unsigned PReg, unsigned Width) const {
using namespace Hexagon;
bool Is64 = DoubleRegsRegClass.contains(PReg);
assert(PReg == 0 || Is64 || IntRegsRegClass.contains(PReg));
static const unsigned Phys32[] = { R0, R1, R2, R3, R4, R5 };
static const unsigned Phys64[] = { D0, D1, D2 };
const unsigned Num32 = sizeof(Phys32)/sizeof(unsigned);
const unsigned Num64 = sizeof(Phys64)/sizeof(unsigned);
// Return the first parameter register of the required width.
if (PReg == 0)
return (Width <= 32) ? Phys32[0] : Phys64[0];
// Set Idx32, Idx64 in such a way that Idx+1 would give the index of the
// next register.
unsigned Idx32 = 0, Idx64 = 0;
if (!Is64) {
while (Idx32 < Num32) {
if (Phys32[Idx32] == PReg)
break;
Idx32++;
}
Idx64 = Idx32/2;
} else {
while (Idx64 < Num64) {
if (Phys64[Idx64] == PReg)
break;
Idx64++;
}
Idx32 = Idx64*2+1;
}
if (Width <= 32)
return (Idx32+1 < Num32) ? Phys32[Idx32+1] : 0;
return (Idx64+1 < Num64) ? Phys64[Idx64+1] : 0;
}
unsigned HexagonEvaluator::getVirtRegFor(unsigned PReg) const {
for (std::pair<unsigned,unsigned> P : MRI.liveins())
if (P.first == PReg)
return P.second;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink