view release on metacpan or  search on metacpan

libjit/attic/jit-rules-alpha.h  view on Meta::CPAN

	{   "s0",  9, -1, JIT_REG_ALPHA_INT | JIT_REG_GLOBAL}, \
 	{   "s1", 10, -1, JIT_REG_ALPHA_INT | JIT_REG_GLOBAL}, \
	{   "s2", 11, -1, JIT_REG_ALPHA_INT | JIT_REG_GLOBAL}, \
	{   "s3", 12, -1, JIT_REG_ALPHA_INT | JIT_REG_GLOBAL}, \
	{   "s4", 13, -1, JIT_REG_ALPHA_INT | JIT_REG_GLOBAL}, \
	{   "s5", 14, -1, JIT_REG_ALPHA_INT | JIT_REG_GLOBAL}, \
	{   "fp", 15, -1, JIT_REG_FIXED | JIT_REG_FRAME}, \
	{   "a0", 16, -1, JIT_REG_FIXED}, \
	{   "a1", 17, -1, JIT_REG_FIXED}, \
	{   "a2", 18, -1, JIT_REG_FIXED}, \
	{   "a3", 19, -1, JIT_REG_FIXED}, \
	{   "a4", 20, -1, JIT_REG_FIXED}, \
	{   "a5", 21, -1, JIT_REG_FIXED}, \
	{   "t8", 22, -1, JIT_REG_ALPHA_INT | JIT_REG_CALL_USED}, \
	{   "t9", 23, -1, JIT_REG_ALPHA_INT | JIT_REG_CALL_USED}, \
	{  "t10", 24, -1, JIT_REG_ALPHA_INT | JIT_REG_CALL_USED}, \
	{  "t11", 25, -1, JIT_REG_ALPHA_INT | JIT_REG_CALL_USED}, \
	{   "ra", 26, -1, JIT_REG_FIXED}, \
	{   "pv", 27, -1, JIT_REG_FIXED}, \
	{   "at", 28, -1, JIT_REG_FIXED}, \
	{   "gp", 29, -1, JIT_REG_FIXED}, \
	{   "sp", 30, -1, JIT_REG_FIXED | JIT_REG_STACK_PTR}, \
	{ "zero", 31, -1, JIT_REG_FIXED}, \
	{  "fv0", 0, -1, JIT_REG_FIXED}, \
	{  "fv1", 1, -1, JIT_REG_FIXED}, \
	{  "fs0", 2, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "fs1", 3, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "fs2", 4, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "fs3", 5, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "fs4", 6, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "fs5", 7, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "fs6", 8, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "fs7", 9, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_GLOBAL}, \
	{  "ft0", 10, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_CALL_USED}, \
	{  "ft1", 11, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_CALL_USED}, \
	{  "ft2", 12, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_CALL_USED}, \
	{  "ft3", 13, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_CALL_USED}, \
	{  "ft4", 14, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_CALL_USED}, \
	{  "ft5", 15, -1, JIT_REG_ALPHA_FLOAT | JIT_REG_CALL_USED}, \
	{  "fa0", 16, -1, JIT_REG_FIXED}, \
	{  "fa1", 17, -1, JIT_REG_FIXED}, \
	{  "fa2", 18, -1, JIT_REG_FIXED}, \
	{  "fa3", 19, -1, JIT_REG_FIXED}, \
	{  "fa4", 20, -1, JIT_REG_FIXED}, \
	{  "fa5", 21, -1, JIT_REG_FIXED}, \
	{  "fe0", 22, -1, JIT_REG_FIXED}, \
	{  "fe1", 23, -1, JIT_REG_FIXED}, \
	{  "fe2", 24, -1, JIT_REG_FIXED}, \
	{  "fe3", 25, -1, JIT_REG_FIXED}, \
	{  "fe4", 26, -1, JIT_REG_FIXED}, \
	{  "fe5", 27, -1, JIT_REG_FIXED}, \
	{  "fe6", 28, -1, JIT_REG_FIXED}, \
	{  "fe7", 29, -1, JIT_REG_FIXED}, \
	{  "fe8", 30, -1, JIT_REG_FIXED}, \
	{"fzero", 31, -1, JIT_REG_FIXED},

/* 32 floating-point registers + 32 integer registers */
#define JIT_NUM_REGS			64

/*
 * The number of registers that are used for global register 
 * allocation. Set to zero if global register allocation should not be 
 * used.
 */
#define JIT_NUM_GLOBAL_REGS		14

/*
 * Define to 1 if we should always load values into registers
 * before operating on them.  i.e. the CPU does not have reg-mem
 * and mem-reg addressing modes.
 *
 * The maximum number of operands for an alpha instruction is 3,
 * all of which must be registers.
 */
#define JIT_ALWAYS_REG_REG		1

/*
 * The maximum number of bytes to allocate for the prolog.
 * This may be shortened once we know the true prolog size.
 */
#define JIT_PROLOG_SIZE			(7 /* instructions */ * 4 /* bytes per instruction */)

/*
 * Preferred alignment for the start of functions.
 *
 * Use the alignment that gcc uses. See gcc/config/alpha/alpha.h
 */
#define JIT_FUNCTION_ALIGNMENT		32

/*
 * Define this to 1 if the platform allows reads and writes on
 * any byte boundary.  Define to 0 if only properly-aligned
 * memory accesses are allowed.
 *
 * All memory access on alpha must be naturally aligned. There are 
 * unaligned load and store instructions to operate on arbitrary byte 
 * boundaries. However sometimes compilers don't always spot where 
 * to use them due to programming tricks with pointers. The kernel will 
 * do the fetch transparently if the access is unaligned and not done 
 * with the proper instructions. Kernel assisted unaligned accesses 
 * don't change the behavior of the program. 
 *
 * TODO: benchmark this to determine what is more costly... setting
 * up everything to be aligned or dealing with the unaligned accesses.
 */
#define JIT_ALIGN_OVERRIDES		1

/*
 * The jit_extra_gen_state macro can be supplied to add extra fields to 
 * the struct jit_gencode type in jit-rules.h, for extra CPU-specific 
 * code generation state information.
 */
#define jit_extra_gen_state		/* empty */;

/*
 * The jit_extra_gen_init macro initializes this extra information, and 
 * the jit_extra_gen_cleanup macro cleans it up when code generation is 
 * complete.
 */
#define jit_extra_gen_init(gen)		do { ; } while (0)
#define jit_extra_gen_cleanup(gen)	do { ; } while (0)