include/jitcs_vreg.h

   1 //===-- jitcs_vregref.h - Class to represent a single basic block --*- C++ -*-===//
   2 //
   3 // A basicblock contains nodes, and must end in a terminal instruction node.
   4 // Nodes can be instructions, constants. Each node may produce more than one
   5 // result.
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef _JITCS_VREG_H_
  10 #define _JITCS_VREG_H_
  11
  12 #include "jitcs_ids.h"
  13 //#include "jitcs_fragment.h"
  14
  15 namespace jitcs {
  16 class IDumper;
  17 struct MemData;
  18
  19 struct VRegPlacement {
  20   int modeNOffset;
  21
  22   bool isPlaced() const { return modeNOffset != 0; }
  23   bool isMem() const { return isPlaced(); }
  24
  25   void unplace() {
  26     modeNOffset = (0 << MMODE_Bits) | MMODE_None;
  27   }
  28   void place(uint fpmode, int ofs) {
  29     assert(fpmode >= MMODE_SPRel && fpmode < MMODE_SPRel + MMODE_FPCount);
  30     assert((ofs << MMODE_Bits) >> MMODE_Bits == ofs);
  31     modeNOffset = (ofs << 4) | (fpmode);
  32   }
  33   int getFP() { assert(isPlaced()); return (modeNOffset & 15) - MMODE_SPRel; }
  34   int getOffset() { assert(isPlaced()); return modeNOffset >> 4; }
  35   static VRegPlacement MakeEmpty() { VRegPlacement p; p.unplace(); return p; }
  36   static VRegPlacement MakeMem(uint fp, int ofs) { VRegPlacement p; p.place(fp, ofs); return p; }
  37
  38   void dump(IDumper& o) const;
  39 };
  40
  41 struct VReg {
  42   RegId id;
  43   ResId res;
  44   RegClassId regclass;
  45   ResClassId resclass;
  46   u32 mask;
  47   u8 sz;
  48   VRegPlacement spillplacement;
  49   MemData* memref;
  50   u32 spillCount, reloadCount;
  51 //  XFragmentList fragments;
  52
  53   void dump(IDumper&) const;
  54
  55   void setupDynamic(size_t vregno, RegClassId rc, u32 mask = 0, u8 sz = 0);
  56   static VReg CreateStatic(RegId hwr, ResId, RegClassId, ResClassId, u8 sz);
  57
  58   bool getsSpilled() const { return spillCount > 0; }
  59   bool getsReloaded() const { return reloadCount > 0; }
  60 };
  61
  62 struct VRegRef {
  63   VReg const* _ptr;
  64
  65   void operator =(VReg const* v) { _ptr = v; }
  66
  67   void clear() { _ptr = jitcs_nullptr; }
  68   VReg const* toVReg() const { return _ptr; }
  69   operator VReg const*() const { return toVReg(); }
  70
  71   VReg* toMutableVReg() {
  72     VReg const* v = toVReg();
  73     assert(v->isMutable());
  74     return const_cast<VReg*>(v);
  75   }
  76
  77   RegId getId() const { return toVReg()->id; }
  78   ResId getRes() const { return toVReg()->res; }
  79   RegClassId getRegClass() const { return toVReg()->regclass; }
  80   ResClassId getResClass() const { return toVReg()->resclass; }
  81
  82   bool isHWReg() const { return getId() < R_HardwareLimit; }
  83   bool isEmpty() const { return _ptr == jitcs_nullptr; }
  84   bool isValid() const { return !isEmpty(); }
  85
  86   static VRegRef Make(VReg const* r) { VRegRef v; v._ptr; return v; }
  87 };
  88 inline bool operator ==(VRegRef r1, VRegRef r2) { return r1._ptr == r2._ptr; }
  89 inline bool operator !=(VRegRef r1, VRegRef r2) { return r1._ptr != r2._ptr; }
  90
  91 } // End EVM namespace
  92
  93 #endif
  94 // _JITCS_VREGREF_H_