Changeset 4218


Ignore:
Timestamp:
Oct 6, 2014, 5:15:54 PM (5 years ago)
Author:
nmedfort
Message:

Compacted unicode category handling code via compile-time directives.

Location:
icGREP/icgrep-devel/icgrep
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/llvm_gen.cpp

    r4217 r4218  
    1111using namespace pablo;
    1212
    13 Ps* fPs = NULL; Nl* fNl = NULL; No* fNo = NULL; Lo* fLo = NULL; Ll* fLl = NULL; Lm* fLm = NULL; Nd* fNd = NULL;
    14 Pc* fPc = NULL; Lt* fLt = NULL; Lu* fLu = NULL; Pf* fPf = NULL; Pd* fPd = NULL; Pe* fPe = NULL; Pi* fPi = NULL;
    15 Po* fPo = NULL; Me* fMe = NULL; Mc* fMc = NULL; Mn* fMn = NULL; Sk* fSk = NULL; So* fSo = NULL; Sm* fSm = NULL;
    16 Sc* fSc = NULL; Zl* fZl = NULL; Co* fCo = NULL; Cn* fCn = NULL; Cc* fCc = NULL; Cf* fCf = NULL; Cs* fCs = NULL;
    17 Zp* fZp = NULL; Zs* fZs = NULL;
    18 
    1913extern "C" {
    2014  void wrapped_print_register(BitBlock bit_block) {
     
    2317}
    2418
    25 extern "C" {
    26     BitBlock wrapped_get_category_Ps(Basis_bits &basis_bits){
    27         if (fPs == nullptr) fPs = new Ps();
    28         Struct_Ps ps_output;
    29         fPs->do_block(basis_bits, ps_output);
    30 
    31         return ps_output.cc;
    32     }
    33 }
    34 
    35 extern "C" {
    36     BitBlock wrapped_get_category_Nl(Basis_bits &basis_bits){
    37         if (fNl == nullptr) fNl = new Nl();
    38         Struct_Nl nl_output;
    39         fNl->do_block(basis_bits, nl_output);
    40 
    41         return nl_output.cc;
    42     }
    43 }
    44 
    45 extern "C" {
    46     BitBlock wrapped_get_category_No(Basis_bits &basis_bits){
    47         if (fNo == nullptr) fNo = new No();
    48         Struct_No no_output;
    49         fNo->do_block(basis_bits, no_output);
    50 
    51         return no_output.cc;
    52     }
    53 }
    54 
    55 extern "C" {
    56     BitBlock wrapped_get_category_Lo(Basis_bits &basis_bits){
    57         if (fLo == nullptr) fLo = new Lo();
    58         Struct_Lo lo_output;
    59         fLo->do_block(basis_bits, lo_output);
    60 
    61         return lo_output.cc;
    62     }
    63 }
    64 
    65 extern "C" {
    66     BitBlock wrapped_get_category_Ll(Basis_bits &basis_bits){
    67         if (fLl == nullptr) fLl = new Ll();
    68         Struct_Ll ll_output;
    69         fLl->do_block(basis_bits, ll_output);
    70 
    71         return ll_output.cc;
    72     }
    73 }
    74 
    75 extern "C" {
    76     BitBlock wrapped_get_category_Lm(Basis_bits &basis_bits){
    77         if (fLm == nullptr) fLm = new Lm();
    78         Struct_Lm lm_output;
    79         fLm->do_block(basis_bits, lm_output);
    80 
    81         return lm_output.cc;
    82     }
    83 }
    84 
    85 extern "C" {
    86     BitBlock wrapped_get_category_Nd(Basis_bits &basis_bits){
    87         if (fNd == nullptr) fNd = new Nd();
    88         Struct_Nd nd_output;
    89         fNd->do_block(basis_bits, nd_output);
    90 
    91         return nd_output.cc;
    92     }
    93 }
    94 
    95 extern "C" {
    96     BitBlock wrapped_get_category_Pc(Basis_bits &basis_bits){
    97         if (fPc == nullptr) fPc = new Pc();
    98         Struct_Pc pc_output;
    99         fPc->do_block(basis_bits, pc_output);
    100 
    101         return pc_output.cc;
    102     }
    103 }
    104 
    105 extern "C" {
    106     BitBlock wrapped_get_category_Lt(Basis_bits &basis_bits){
    107         if (fLt == nullptr) fLt = new Lt();
    108         Struct_Lt lt_output;
    109         fLt->do_block(basis_bits, lt_output);
    110 
    111         return lt_output.cc;
    112     }
    113 }
    114 
    115 extern "C" {
    116     BitBlock wrapped_get_category_Lu(Basis_bits &basis_bits){
    117         if (fLu == nullptr) fLu = new Lu();
    118         Struct_Lu lu_output;
    119         fLu->do_block(basis_bits, lu_output);
    120 
    121         return lu_output.cc;
    122     }
    123 }
    124 
    125 extern "C" {
    126     BitBlock wrapped_get_category_Pf(Basis_bits &basis_bits){
    127         if (fPf == nullptr) fPf = new Pf();
    128         Struct_Pf pf_output;
    129         fPf->do_block(basis_bits, pf_output);
    130 
    131         return pf_output.cc;
    132     }
    133 }
    134 
    135 extern "C" {
    136     BitBlock wrapped_get_category_Pd(Basis_bits &basis_bits){
    137         if (fPd == nullptr) fPd = new Pd();
    138         Struct_Pd pd_output;
    139         fPd->do_block(basis_bits, pd_output);
    140 
    141         return pd_output.cc;
    142     }
    143 }
    144 
    145 extern "C" {
    146     BitBlock wrapped_get_category_Pe(Basis_bits &basis_bits){
    147         if (fPe == nullptr) fPe = new Pe();
    148         Struct_Pe pe_output;
    149         fPe->do_block(basis_bits, pe_output);
    150 
    151         return pe_output.cc;
    152     }
    153 }
    154 
    155 extern "C" {
    156     BitBlock wrapped_get_category_Pi(Basis_bits &basis_bits){
    157         if (fPi == nullptr) fPi = new Pi();
    158         Struct_Pi pi_output;
    159         fPi->do_block(basis_bits, pi_output);
    160 
    161         return pi_output.cc;
    162     }
    163 }
    164 
    165 extern "C" {
    166     BitBlock wrapped_get_category_Po(Basis_bits &basis_bits){
    167         if (fPo == nullptr) fPo = new Po();
    168         Struct_Po po_output;
    169         fPo->do_block(basis_bits, po_output);
    170 
    171         return po_output.cc;
    172     }
    173 }
    174 
    175 extern "C" {
    176     BitBlock wrapped_get_category_Me(Basis_bits &basis_bits){
    177         if (fMe == nullptr) fMe = new Me();
    178         Struct_Me me_output;
    179         fMe->do_block(basis_bits, me_output);
    180 
    181         return me_output.cc;
    182     }
    183 }
    184 
    185 extern "C" {
    186     BitBlock wrapped_get_category_Mc(Basis_bits &basis_bits){
    187         if (fMc == nullptr) fMc = new Mc();
    188         Struct_Mc mc_output;
    189         fMc->do_block(basis_bits, mc_output);
    190 
    191         return mc_output.cc;
    192     }
    193 }
    194 
    195 extern "C" {
    196     BitBlock wrapped_get_category_Mn(Basis_bits &basis_bits){
    197         if (fMn == nullptr) fMn = new Mn();
    198         Struct_Mn mn_output;
    199         fMn->do_block(basis_bits, mn_output);
    200 
    201         return mn_output.cc;
    202     }
    203 }
    204 
    205 extern "C" {
    206     BitBlock wrapped_get_category_Sk(Basis_bits &basis_bits){
    207         if (fSk == nullptr) fSk = new Sk();
    208         Struct_Sk sk_output;
    209         fSk->do_block(basis_bits, sk_output);
    210 
    211         return sk_output.cc;
    212     }
    213 }
    214 
    215 extern "C" {
    216     BitBlock wrapped_get_category_So(Basis_bits &basis_bits){
    217         if (fSo == nullptr) fSo = new So();
    218         Struct_So so_output;
    219         fSo->do_block(basis_bits, so_output);
    220 
    221         return so_output.cc;
    222     }
    223 }
    224 
    225 extern "C" {
    226     BitBlock wrapped_get_category_Sm(Basis_bits &basis_bits){
    227         if (fSm == nullptr) fSm = new Sm();
    228         Struct_Sm sm_output;
    229         fSm->do_block(basis_bits, sm_output);
    230 
    231         return sm_output.cc;
    232     }
    233 }
    234 
    235 extern "C" {
    236     BitBlock wrapped_get_category_Sc(Basis_bits &basis_bits){
    237         if (fSc == nullptr) fSc = new Sc();
    238         Struct_Sc sc_output;
    239         fSc->do_block(basis_bits, sc_output);
    240 
    241         return sc_output.cc;
    242     }
    243 }
    244 
    245 extern "C" {
    246     BitBlock wrapped_get_category_Zl(Basis_bits &basis_bits){
    247         if (fZl == nullptr) fZl = new Zl();
    248         Struct_Zl zl_output;
    249         fZl->do_block(basis_bits, zl_output);
    250 
    251         return zl_output.cc;
    252     }
    253 }
    254 
    255 extern "C" {
    256     BitBlock wrapped_get_category_Co(Basis_bits &basis_bits){
    257         if (fCo == nullptr) fCo = new Co();
    258         Struct_Co co_output;
    259         fCo->do_block(basis_bits, co_output);
    260 
    261         return co_output.cc;
    262     }
    263 }
    264 
    265 extern "C" {
    266     BitBlock wrapped_get_category_Cn(Basis_bits &basis_bits){
    267         if (fCn == nullptr) fCn = new Cn();
    268         Struct_Cn cn_output;
    269         fCn->do_block(basis_bits, cn_output);
    270 
    271         return cn_output.cc;
    272     }
    273 }
    274 
    275 extern "C" {
    276     BitBlock wrapped_get_category_Cc(Basis_bits &basis_bits){
    277         if (fCc == nullptr) fCc = new Cc();
    278         Struct_Cc cc_output;
    279         fCc->do_block(basis_bits, cc_output);
    280 
    281         return cc_output.cc;
    282     }
    283 }
    284 
    285 extern "C" {
    286     BitBlock wrapped_get_category_Cf(Basis_bits &basis_bits){
    287         if (fCf == nullptr) fCf = new Cf();
    288         Struct_Cf cf_output;
    289         fCf->do_block(basis_bits, cf_output);
    290 
    291         return cf_output.cc;
    292     }
    293 }
    294 
    295 extern "C" {
    296     BitBlock wrapped_get_category_Cs(Basis_bits &basis_bits){
    297         if (fCs == nullptr) fCs = new Cs();
    298         Struct_Cs cs_output;
    299         fCs->do_block(basis_bits, cs_output);
    300 
    301         return cs_output.cc;
    302     }
    303 }
    304 
    305 extern "C" {
    306     BitBlock wrapped_get_category_Zp(Basis_bits &basis_bits){
    307         if (fZp == nullptr) fZp = new Zp();
    308         Struct_Zp zp_output;
    309         fZp->do_block(basis_bits, zp_output);
    310 
    311         return zp_output.cc;
    312     }
    313 }
    314 
    315 extern "C" {
    316     BitBlock wrapped_get_category_Zs(Basis_bits &basis_bits){
    317         if (fZs == nullptr) fZs = new Zs();
    318         Struct_Zs zs_output;
    319         fZs->do_block(basis_bits, zs_output);
    320 
    321         return zs_output.cc;
    322     }
    323 }
     19#define CREATE_GENERAL_CODE_CATEGORY(SUFFIX) \
     20SUFFIX * f##SUFFIX = nullptr; \
     21extern "C" { \
     22    BitBlock __get_category_##SUFFIX(Basis_bits &basis_bits) { \
     23        if (f##SUFFIX == nullptr) f##SUFFIX = new SUFFIX(); \
     24        Struct_##SUFFIX output; \
     25        f##SUFFIX->do_block(basis_bits, output); \
     26        return output.cc; \
     27    } \
     28}
     29
     30CREATE_GENERAL_CODE_CATEGORY(Cc)
     31CREATE_GENERAL_CODE_CATEGORY(Cf)
     32CREATE_GENERAL_CODE_CATEGORY(Cn)
     33CREATE_GENERAL_CODE_CATEGORY(Co)
     34CREATE_GENERAL_CODE_CATEGORY(Cs)
     35CREATE_GENERAL_CODE_CATEGORY(Ll)
     36CREATE_GENERAL_CODE_CATEGORY(Lm)
     37CREATE_GENERAL_CODE_CATEGORY(Lo)
     38CREATE_GENERAL_CODE_CATEGORY(Lt)
     39CREATE_GENERAL_CODE_CATEGORY(Lu)
     40CREATE_GENERAL_CODE_CATEGORY(Mc)
     41CREATE_GENERAL_CODE_CATEGORY(Me)
     42CREATE_GENERAL_CODE_CATEGORY(Mn)
     43CREATE_GENERAL_CODE_CATEGORY(Nd)
     44CREATE_GENERAL_CODE_CATEGORY(Nl)
     45CREATE_GENERAL_CODE_CATEGORY(No)
     46CREATE_GENERAL_CODE_CATEGORY(Pc)
     47CREATE_GENERAL_CODE_CATEGORY(Pd)
     48CREATE_GENERAL_CODE_CATEGORY(Pe)
     49CREATE_GENERAL_CODE_CATEGORY(Pf)
     50CREATE_GENERAL_CODE_CATEGORY(Pi)
     51CREATE_GENERAL_CODE_CATEGORY(Po)
     52CREATE_GENERAL_CODE_CATEGORY(Ps)
     53CREATE_GENERAL_CODE_CATEGORY(Sc)
     54CREATE_GENERAL_CODE_CATEGORY(Sk)
     55CREATE_GENERAL_CODE_CATEGORY(Sm)
     56CREATE_GENERAL_CODE_CATEGORY(So)
     57CREATE_GENERAL_CODE_CATEGORY(Zl)
     58CREATE_GENERAL_CODE_CATEGORY(Zp)
     59CREATE_GENERAL_CODE_CATEGORY(Zs)
     60
     61#undef CREATE_GENERAL_CODE_CATEGORY
    32462
    32563LLVM_Generator::LLVM_Generator(std::map<std::string, std::string> name_map, std::string basis_pattern, int bits)
    326 {
    327     m_name_map = name_map;
    328     mBasisBitPattern = basis_pattern;
    329     mBits = bits;
     64: m_name_map(name_map)
     65, mCalleeMap(nullptr)
     66, mBasisBitPattern(basis_pattern)
     67, mBits(bits)
     68{
     69
    33070}
    33171
     
    33373{
    33474    delete mMod;
    335 
    33675    delete fPs;
    33776    delete fNl;
     
    649388    if (const Call * pablo_call = dyn_cast<const Call>(expr))
    650389    {
    651         std::string callee = "wrapped_get_category_" + pablo_call->getCallee();
     390        std::string callee = "__get_category_" + pablo_call->getCallee();
    652391        if (mMarkerMap.find(callee) == mMarkerMap.end())
    653392        {
     393            if (mCalleeMap == nullptr) {
     394                mCalleeMap = new CalleeMapType();
     395                #define ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(SUFFIX) \
     396                    mCalleeMap->insert(std::make_pair(#SUFFIX, (void *)&__get_category_##SUFFIX));
     397                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Cc)
     398                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Cf)
     399                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Cn)
     400                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Co)
     401                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Cs)
     402                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Ll)
     403                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Lm)
     404                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Lo)
     405                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Lt)
     406                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Lu)
     407                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Mc)
     408                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Me)
     409                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Mn)
     410                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Nd)
     411                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Nl)
     412                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(No)
     413                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Pc)
     414                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Pd)
     415                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Pe)
     416                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Pf)
     417                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Pi)
     418                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Po)
     419                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Ps)
     420                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Sc)
     421                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Sk)
     422                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Sm)
     423                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(So)
     424                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Zl)
     425                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Zp)
     426                ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP(Zs)
     427                #undef ADD_GENERAL_CODE_CATEGORY_CALL_TO_MAP
     428            }
    654429            Value* func_get_unicode_category = mMod->getOrInsertFunction(callee, mXi64Vect, mBasisBitsInputPtr, NULL);
    655             void* addr;
    656             if (pablo_call->getCallee() == "Ps")
    657             {
    658                 addr = (void *)&wrapped_get_category_Ps;
     430            void * addr = mCalleeMap->find(pablo_call->getCallee())->second;
     431            if (addr == nullptr) {
     432                throw std::runtime_error("Unknown Unicode Category \"" + callee + "\"");
    659433            }
    660             else if (pablo_call->getCallee() == "Nl")
    661             {
    662                 addr = (void *)&wrapped_get_category_Nl;
    663             }
    664             else if (pablo_call->getCallee() == "No")
    665             {
    666                 addr = (void *)&wrapped_get_category_No;
    667             }
    668             else if (pablo_call->getCallee() == "Lo")
    669             {
    670                 addr = (void *)&wrapped_get_category_Lo;
    671             }
    672             else if (pablo_call->getCallee() == "Ll")
    673             {
    674                 addr = (void *)&wrapped_get_category_Ll;
    675             }
    676             else if (pablo_call->getCallee() == "Lm")
    677             {
    678                 addr = (void *)&wrapped_get_category_Lm;
    679             }
    680             else if (pablo_call->getCallee() == "Nd")
    681             {
    682                 addr = (void *)&wrapped_get_category_Nd;
    683             }
    684             else if (pablo_call->getCallee() == "Pc")
    685             {
    686                 addr = (void *)&wrapped_get_category_Pc;
    687             }
    688             else if (pablo_call->getCallee() == "Lt")
    689             {
    690                 addr = (void *)&wrapped_get_category_Lt;
    691             }
    692             else if (pablo_call->getCallee() == "Lu")
    693             {
    694                 addr = (void *)&wrapped_get_category_Lu;
    695             }
    696             else if (pablo_call->getCallee() == "Pf")
    697             {
    698                 addr = (void *)&wrapped_get_category_Pf;
    699             }
    700             else if (pablo_call->getCallee() == "Pd")
    701             {
    702                 addr = (void *)&wrapped_get_category_Pd;
    703             }
    704             else if (pablo_call->getCallee() == "Pe")
    705             {
    706                 addr = (void *)&wrapped_get_category_Pe;
    707             }
    708             else if (pablo_call->getCallee() == "Pi")
    709             {
    710                 addr = (void *)&wrapped_get_category_Pi;
    711             }
    712             else if (pablo_call->getCallee() == "Po")
    713             {
    714                 addr = (void *)&wrapped_get_category_Po;
    715             }
    716             else if (pablo_call->getCallee() == "Me")
    717             {
    718                 addr = (void *)&wrapped_get_category_Me;
    719             }
    720             else if (pablo_call->getCallee() == "Mc")
    721             {
    722                 addr = (void *)&wrapped_get_category_Mc;
    723             }
    724             else if (pablo_call->getCallee() == "Mn")
    725             {
    726                 addr = (void *)&wrapped_get_category_Mn;
    727             }
    728             else if (pablo_call->getCallee() == "Sk")
    729             {
    730                 addr = (void *)&wrapped_get_category_Sk;
    731             }
    732             else if (pablo_call->getCallee() == "So")
    733             {
    734                 addr = (void *)&wrapped_get_category_So;
    735             }
    736             else if (pablo_call->getCallee() == "Sm")
    737             {
    738                 addr = (void *)&wrapped_get_category_Sm;
    739             }
    740             else if (pablo_call->getCallee() == "Sc")
    741             {
    742                 addr = (void *)&wrapped_get_category_Sc;
    743             }
    744             else if (pablo_call->getCallee() == "Zl")
    745             {
    746                 addr = (void *)&wrapped_get_category_Zl;
    747             }
    748             else if (pablo_call->getCallee() == "Co")
    749             {
    750                 addr = (void *)&wrapped_get_category_Co;
    751             }
    752             else if (pablo_call->getCallee() == "Cn")
    753             {
    754                 addr = (void *)&wrapped_get_category_Cn;
    755             }
    756             else if (pablo_call->getCallee() == "Cc")
    757             {
    758                 addr = (void *)&wrapped_get_category_Cc;
    759             }
    760             else if (pablo_call->getCallee() == "Cf")
    761             {
    762                 addr = (void *)&wrapped_get_category_Cf;
    763             }
    764             else if (pablo_call->getCallee() == "Cs")
    765             {
    766                 addr = (void *)&wrapped_get_category_Cs;
    767             }
    768             else if (pablo_call->getCallee() == "Zp")
    769             {
    770                 addr = (void *)&wrapped_get_category_Zp;
    771             }
    772             else if (pablo_call->getCallee() == "Zs")
    773             {
    774                 addr = (void *)&wrapped_get_category_Zs;
    775             }
    776 
    777434            mExecutionEngine->addGlobalMapping(cast<GlobalValue>(func_get_unicode_category), addr);
    778435            mMarkerMap.insert(make_pair(callee, func_get_unicode_category));
     
    989646        auto f = mMarkerMap.find(call->getCallee());
    990647        if (f == mMarkerMap.end()) {
    991             std::map<std::string, Value*>::iterator itFuncGet = mMarkerMap.find("wrapped_get_category_" + call->getCallee());
     648            std::map<std::string, Value*>::iterator itFuncGet = mMarkerMap.find("__get_category_" + call->getCallee());
    992649            Value* basis_bits_struct = b.CreateLoad(mBasisBitsAddr);
    993650            Value* unicode_category = b.CreateCall(itFuncGet->second, basis_bits_struct);
     
    1160817Value* LLVM_Generator::genAdvanceWithCarry(Value* strm_value) {
    1161818    IRBuilder<> b(mBasicBlock);
    1162 
    1163819#if (BLOCK_SIZE == 128)
    1164820    int this_carry_idx = mCarryQueueIdx;
     
    1191847#endif
    1192848}
    1193 
    1194 
  • icGREP/icgrep-devel/icgrep/llvm_gen.h

    r4217 r4218  
    2222#include <iostream>
    2323#include <string>
    24 #include <sstream>
    2524#include <list>
     25#include <unordered_map>
    2626#include <map>
    2727#include <algorithm>
     
    8888
    8989class LLVM_Generator {
     90    typedef std::unordered_map<std::string, void *> CalleeMapType;
    9091public:
    9192    LLVM_Generator(std::map<std::string, std::string> name_map, std::string basis_pattern, int bits);
     
    118119    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2);
    119120
    120     int         mBits;
    121     std::map<std::string, std::string> m_name_map;
    122     std::string mBasisBitPattern;
    123 
    124     Module*          mMod;
    125     BasicBlock*      mBasicBlock;
    126 
    127     ExecutionEngine* mExecutionEngine;
     121    int                                 mBits;
     122    std::map<std::string, std::string>  m_name_map;
     123    std::string                         mBasisBitPattern;
     124    Module*                             mMod;
     125    BasicBlock*                         mBasicBlock;
     126    CalleeMapType *                     mCalleeMap;
     127    ExecutionEngine*                    mExecutionEngine;
    128128
    129129    VectorType*  mXi64Vect;
Note: See TracChangeset for help on using the changeset viewer.