[llvm-commits] CVS: llvm/include/llvm/Reoptimizer/BinInterface/regmask.h

[Anand Shukla]

Changes in directory llvm/include/llvm/Reoptimizer/BinInterface:

regmask.h added (r1.1)

---
Log message:

First version of working bininterface API/implementation

---
Diffs of the changes:

Index: llvm/include/llvm/Reoptimizer/BinInterface/regmask.h
diff -c /dev/null llvm/include/llvm/Reoptimizer/BinInterface/regmask.h:1.1
*** /dev/null	Sat May 31 17:16:57 2003
--- llvm/include/llvm/Reoptimizer/BinInterface/regmask.h	Sat May 31 17:16:47 2003
***************
*** 0 ****
--- 1,162 ----
+ //===--------llvm/Reoptimizer/BinInterface/regmask.h--------------*- C++ -*--=//
+ //
+ // Efficient bitfield based register tracker
+ //                          Register Allocator
+ //===----------------------------------------------------------------------===//
+ 
+ 
+ #ifndef __REGMASK_H__
+ #define __REGMASK_H__
+ 
+ #include "bitmath.h"
+ #include <vector>
+ #include <iostream>
+ 
+ #define VREG_ISMEM(x) (x >= 32)
+ #define VREG_ISREG(x) (x <  32)
+ #define VREG_GETMEM(x) ((x-32) * 8)
+ 
+ using std::vector;
+ 
+ class regmask32
+ {
+    private:
+       unsigned   freemap;
+ 
+    public:
+ 
+       // Construct freemap, initially mark everyone free
+       regmask32()
+             : freemap(~0)
+       {
+         //allocreg(); //alloc reg 0 so its never allocated
+       }
+ 
+       // returns 0 on failure
+       unsigned allocreg()
+       {
+ 
+         //freemap &= ~1;
+          unsigned mask = LOWEST_BIT(freemap); // on fail this will be 0
+          freemap &= ~mask;                    // on fail this will be a nop
+ 
+          // log2(0) == log2(1) == 0 (in this implementation!)
+          //std::cout<<log2_bits32(mask)<<"\t -----\n";
+          //printf("Mask = %x\n", mask);
+          return log2_bits32(mask);                      
+ 
+          // I fully realize log2(0) is undefined
+          // mathematically
+       }
+ 
+       // free a register
+       void freereg(unsigned idx)
+       {
+         //if(idx == 0)
+         //return;
+         
+          freemap |= 1 << (idx & 31);   // mark it free
+       }
+ 
+       // force the register 'in-use'
+       void grabreg(unsigned idx)
+       {
+          freemap &= ~(1 << (idx & 31));    // grab it
+       }
+ 
+       void set(unsigned mask)
+       {
+          freemap = mask;
+          //     freemap &= ~1; //so first reg is allocated
+       }
+ 
+       // count how many are free in the lowest 32.
+       unsigned count()
+       {
+          return countbits_dense(freemap);
+       }
+ 
+       // get the mask of free registers
+       unsigned     free()
+       {
+          return freemap;
+       }
+ };
+ 
+ 
+ class regmask
+ {
+    private:
+       vector<regmask32> freemap;
+ 
+       unsigned i_allocreg(unsigned int baseindex)
+       {
+ 	for (;baseindex<freemap.size(); baseindex++)
+ 	  if (freemap[baseindex].free())
+             {
+ 	      unsigned d =  freemap[baseindex].allocreg();
+ 	      return (baseindex << 5) + d;
+             }
+ 	return 0;
+       }
+       
+    public:
+       // Construct freemap, initially mark everyone free
+       regmask(unsigned maxregs)
+ 	{
+          // make sure maxregs is a multiple of 32
+          assert(!(maxregs & 0x1F));
+ 
+          // calculate size of freemap
+          //freemap.inc( maxregs  >> 5 );
+ 	 freemap.resize(maxregs  >> 5);
+          for (unsigned int k = 0; k < freemap.size(); k++)
+             freemap[k].set(~0);
+       }
+ 
+       // returns 0 on failure
+       unsigned allocreg()
+       {
+          return i_allocreg(0);   // alloc physical or memory
+       }
+ 
+       unsigned allocmemreg()
+       {
+          return i_allocreg(1);   // force memory
+       }
+ 
+       // returns 0 on failure
+       unsigned allocreg32() // allocate register from first 32 only
+       {
+          return freemap[0].allocreg();
+       }
+ 
+       void freereg(unsigned idx)
+       {
+          freemap[idx >> 5].freereg(idx & 31);
+       }
+ 
+       void grabreg(unsigned idx)
+       {
+          freemap[idx >> 5].grabreg(idx & 31);    // grab it
+       }
+ 
+       void set32(unsigned mask)
+       {
+          freemap[0].set(mask);
+       }
+ 
+       // count how many are free in the lowest 32.
+       unsigned count32()
+       {
+          return freemap[0].count();
+       }
+ 
+       unsigned  free32()
+       {
+          return freemap[0].free();
+       }
+ };
+ 
+ #endif
+