MCRegisterInfo.c

Go to the documentation of this file.

//=== MC/MCRegisterInfo.cpp - Target Register Description -------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements MCRegisterInfo functions.
//
//===----------------------------------------------------------------------===//
 
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */
 
#include "MCRegisterInfo.h"
 
typedef struct DiffListIterator {
    uint16_t Val;
    const MCPhysReg *List;
} DiffListIterator;
 
void MCRegisterInfo_InitMCRegisterInfo(MCRegisterInfo *RI,
        const MCRegisterDesc *D, unsigned NR,
        unsigned RA, unsigned PC,
        const MCRegisterClass *C, unsigned NC,
        uint16_t (*RURoots)[2], unsigned NRU,
        const MCPhysReg *DL,
        const char *Strings,
        const uint16_t *SubIndices, unsigned NumIndices,
        const uint16_t *RET)
{
    RI->Desc = D;
    RI->NumRegs = NR;
    RI->RAReg = RA;
    RI->PCReg = PC;
    RI->Classes = C;
    RI->DiffLists = DL;
    RI->RegStrings = Strings;
    RI->NumClasses = NC;
    RI->RegUnitRoots = RURoots;
    RI->NumRegUnits = NRU;
    RI->SubRegIndices = SubIndices;
    RI->NumSubRegIndices = NumIndices;
    RI->RegEncodingTable = RET;
}
 
static void DiffListIterator_init(DiffListIterator *d, MCPhysReg InitVal, const MCPhysReg *DiffList)
{
    d->Val = InitVal;
    d->List = DiffList;
}
 
static uint16_t DiffListIterator_getVal(DiffListIterator *d)
{
    return d->Val;
}
 
static bool DiffListIterator_next(DiffListIterator *d)
{
    MCPhysReg D;
 
    if (d->List == 0)
        return false;
 
    D = *d->List;
    d->List++;
    d->Val += D;
 
    if (!D)
        d->List = 0;
 
    return (D != 0);
}
 
static bool DiffListIterator_isValid(DiffListIterator *d)
{
    return (d->List != 0);
}
 
unsigned MCRegisterInfo_getMatchingSuperReg(const MCRegisterInfo *RI, unsigned Reg, unsigned SubIdx, const MCRegisterClass *RC)
{
    DiffListIterator iter;
 
    if (Reg >= RI->NumRegs) {
        return 0;
    }
 
    DiffListIterator_init(&iter, (MCPhysReg)Reg, RI->DiffLists + RI->Desc[Reg].SuperRegs);
    DiffListIterator_next(&iter);
 
    while(DiffListIterator_isValid(&iter)) {
        uint16_t val = DiffListIterator_getVal(&iter);
        if (MCRegisterClass_contains(RC, val) && Reg ==  MCRegisterInfo_getSubReg(RI, val, SubIdx))
            return val;
 
        DiffListIterator_next(&iter);
    }
 
    return 0;
}
 
unsigned MCRegisterInfo_getSubReg(const MCRegisterInfo *RI, unsigned Reg, unsigned Idx)
{
    DiffListIterator iter;
    const uint16_t *SRI = RI->SubRegIndices + RI->Desc[Reg].SubRegIndices;
 
    DiffListIterator_init(&iter, (MCPhysReg)Reg, RI->DiffLists + RI->Desc[Reg].SubRegs);
    DiffListIterator_next(&iter);
 
    while(DiffListIterator_isValid(&iter)) {
        if (*SRI == Idx)
            return DiffListIterator_getVal(&iter);
        DiffListIterator_next(&iter);
        ++SRI;
    }
 
    return 0;
}
 
const MCRegisterClass* MCRegisterInfo_getRegClass(const MCRegisterInfo *RI, unsigned i)
{
    //assert(i < getNumRegClasses() && "Register Class ID out of range");
    if (i >= RI->NumClasses)
        return 0;
    return &(RI->Classes[i]);
}
 
bool MCRegisterClass_contains(const MCRegisterClass *c, unsigned Reg)
{
    unsigned InByte = Reg % 8;
    unsigned Byte = Reg / 8;
 
    if (Byte >= c->RegSetSize)
        return false;
 
    return (c->RegSet[Byte] & (1 << InByte)) != 0;
}