"I am a person who works hard and plays hard."
Yuan Wei
Second Year Graduate Student Department of Computer Science
University of Virginia Charlottesville, VA 22903
Email: yw3f@cs.virginia.edu

Source Code Analysis

Main Page   Compound List   File List   Compound Members   File Members  

alpha.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "host.h"
#include "misc.h"
#include "machine.h"
#include "eval.h"
#include "regs.h"
#include "machine.def"

Include dependency graph for alpha.c:

Include dependency graph

Go to the source code of this file.

Defines

Functions

Variables

Define Documentation

#define CONNECT (  OP    )     offset = max_offset+1; md_opoffset[OP] = offset;
 

#define CONNECT (  OP    ) 
 

#define CONNECT (  OP    ) 
 

#define CONNECT (  OP    ) 
 

#define CONNECT (  OP    ) 
 

#define CONNECT (  OP    ) 
 

#define CONNECT (  OP    ) 
 

#define DEFINST (  OP,
MSK,
NAME,
OPFORM,
RES,
FLAGS,
O1,
O2,
I1,
I2,
I3    ) 
 

Value:

if ((MSK)+offset >= MD_MAX_MASK)                                        \
    panic("MASK_MAX is too small, index==%d", (MSK)+offset);            \
  if (md_mask2op[(MSK)+offset])                                         \
    fatal("doubly defined opcode, index==%d", (MSK)+offset);            \
  md_mask2op[(MSK)+offset]=(OP); max_offset=MAX(max_offset,(MSK)+offset);

#define DEFINST (  OP,
MSK,
NAME,
OPFORM,
RES,
FLAGS,
O1,
O2,
I1,
I2,
I3    )     FLAGS,
 

#define DEFINST (  OP,
MSK,
NAME,
OPFORM,
RES,
FLAGS,
O1,
O2,
I1,
I2,
I3    )     RES,
 

#define DEFINST (  OP,
MSK,
NAME,
OPFORM,
RES,
FLAGS,
O1,
O2,
I1,
I2,
I3    )     OPFORM,
 

#define DEFINST (  OP,
MSK,
NAME,
OPFORM,
RES,
FLAGS,
O1,
O2,
I1,
I2,
I3    )     NAME,
 

#define DEFINST (  OP,
MSK,
NAME,
OPFORM,
RES,
FLAGS,
O1,
O2,
I1,
I2,
I3    )     0,
 

#define DEFINST (  OP,
MSK,
NAME,
OPFORM,
RES,
FLAGS,
O1,
O2,
I1,
I2,
I3    )     0,
 

#define DEFLINK (  OP,
MSK,
NAME,
MASK,
SHIFT    ) 
 

Value:

if ((MSK)+offset >= MD_MAX_MASK)                                        \
    panic("MASK_MAX is too small, index==%d", (MSK)+offset);            \
  if (md_mask2op[(MSK)+offset])                                         \
    fatal("doubly defined opcode, index==%d", (MSK)+offset);            \
  md_mask2op[(MSK)+offset]=(OP); max_offset=MAX(max_offset,(MSK)+offset);

#define DEFLINK (  OP,
MSK,
NAME,
MASK,
SHIFT    )     NA,
 

#define DEFLINK (  OP,
MSK,
NAME,
MASK,
SHIFT    )     FUClamd_NA,
 

#define DEFLINK (  OP,
MSK,
NAME,
MASK,
SHIFT    )     NULL,
 

#define DEFLINK (  OP,
MSK,
NAME,
MASK,
SHIFT    )     NAME,
 

#define DEFLINK (  OP,
MSK,
NAME,
SHIFT,
MASK    )     SHIFT,
 

#define DEFLINK (  OP,
MSK,
NAME,
SHIFT,
MASK    )     MASK,
 

Function Documentation

void md_init_decoder (  void    ) 
 

Definition at line 551 of file alpha.c.

References panic(). 

00552 {
00553   unsigned long max_offset = 0;
00554   unsigned long offset = 0;
00555 
00556 #define DEFINST(OP,MSK,NAME,OPFORM,RES,FLAGS,O1,O2,I1,I2,I3)            \
00557   if ((MSK)+offset >= MD_MAX_MASK)                                      \
00558     panic("MASK_MAX is too small, index==%d", (MSK)+offset);            \
00559   if (md_mask2op[(MSK)+offset])                                         \
00560     fatal("doubly defined opcode, index==%d", (MSK)+offset);            \
00561   md_mask2op[(MSK)+offset]=(OP); max_offset=MAX(max_offset,(MSK)+offset);
00562 
00563 #define DEFLINK(OP,MSK,NAME,MASK,SHIFT)                                 \
00564   if ((MSK)+offset >= MD_MAX_MASK)                                      \
00565     panic("MASK_MAX is too small, index==%d", (MSK)+offset);            \
00566   if (md_mask2op[(MSK)+offset])                                         \
00567     fatal("doubly defined opcode, index==%d", (MSK)+offset);            \
00568   md_mask2op[(MSK)+offset]=(OP); max_offset=MAX(max_offset,(MSK)+offset);
00569 
00570 #define CONNECT(OP)                                                     \
00571     offset = max_offset+1; md_opoffset[OP] = offset;
00572 
00573 #include "machine.def"
00574 
00575   if (max_offset >= MD_MAX_MASK)
00576     panic("MASK_MAX is too small, index==%d", max_offset);
00577 }

void md_print_creg (  md_ctrl_t    regs,
int    reg,
FILE *    stream
) 
 

Definition at line 490 of file alpha.c.

References md_ctrl_t::fpcr, myfprintf(), panic(), and md_ctrl_t::uniq. 

00491 {
00492   /* index is only used to iterate over these registers, hence no enums... */
00493   switch (reg)
00494     {
00495     case 0:
00496       myfprintf(stream, "FPCR: 0x%012lx", regs.fpcr);
00497       break;
00498 
00499     case 1:
00500       myfprintf(stream, "UNIQ: 0x%012lx", regs.uniq);
00501       break;
00502 
00503     default:
00504       panic("bogus control register index");
00505     }
00506 }

void md_print_cregs (  md_ctrl_t    regs,
FILE *    stream
) 
 

Definition at line 509 of file alpha.c.

References md_print_creg(). 

00510 {
00511   md_print_creg(regs, 0, stream);
00512   fprintf(stream, "  ");
00513   md_print_creg(regs, 1, stream);
00514   fprintf(stream, "\n");
00515 }

void md_print_fpreg (  md_fpr_t    regs,
int    reg,
FILE *    stream
) 
 

Definition at line 467 of file alpha.c.

References md_fpr_t::d, md_reg_name(), myfprintf(), and md_fpr_t::q. 

00468 {
00469   myfprintf(stream, "%4s: %16ld/0x%012lx/%f",
00470             md_reg_name(rt_fpr, reg), regs.q[reg], regs.q[reg], regs.d[reg]);
00471 }

void md_print_fpregs (  md_fpr_t    regs,
FILE *    stream
) 
 

Definition at line 474 of file alpha.c.

References md_print_fpreg(). 

00475 {
00476   int i;
00477 
00478   /* floating point registers */
00479   for (i=0; i < MD_NUM_FREGS; i += 2)
00480     {
00481       md_print_fpreg(regs, i, stream);
00482       fprintf(stream, "\n");
00483 
00484       md_print_fpreg(regs, i+1, stream);
00485       fprintf(stream, "\n");
00486     }
00487 }

void md_print_insn (  md_inst_t    inst,
md_addr_t    pc,
FILE *    stream
) 
 

Definition at line 581 of file alpha.c.

References MD_OP_FORMAT, MD_OP_NAME, MD_SET_OPCODE, myfprintf(), s, SEXT, SEXT21, sword_t, and word_t. 

00584 {
00585   enum md_opcode op;
00586 
00587   /* use stderr as default output stream */
00588   if (!stream)
00589     stream = stderr;
00590 
00591   /* decode the instruction, assumes predecoded text segment */
00592   MD_SET_OPCODE(op, inst);
00593 
00594   /* disassemble the instruction */
00595   if (op <= OP_NA || op >= OP_MAX)
00596     {
00597       /* bogus instruction */
00598       fprintf(stream, "<invalid inst: 0x%08x>", inst);
00599     }
00600   else
00601     {
00602       char *s;
00603 
00604       /* FIXME: %-10s crashes on Suns!!! */
00605       fprintf(stream, "%s ", MD_OP_NAME(op));
00606 
00607       s = MD_OP_FORMAT(op);
00608       while (*s) {
00609         switch (*s) {
00610         case 'a':
00611           fprintf(stream, "r%d", RA);
00612           break;
00613         case 'b':
00614           fprintf(stream, "r%d", RB);
00615           break;
00616         case 'c':
00617           fprintf(stream, "r%d", RC);
00618           break;
00619         case 'A':
00620           fprintf(stream, "f%d", RA);
00621           break;
00622         case 'B':
00623           fprintf(stream, "f%d", RB);
00624           break;
00625         case 'C':
00626           fprintf(stream, "f%d", RC);
00627           break;
00628         case 'o':
00629           fprintf(stream, "%d", (sword_t)SEXT(OFS));
00630           break;
00631         case 'j':
00632           myfprintf(stream, "0x%p", pc + (SEXT(OFS) << 2) + 4);
00633           break;
00634         case 'J':
00635           myfprintf(stream, "0x%p", pc + (SEXT21(TARG) << 2) + 4);
00636           break;
00637         case 'i':
00638           fprintf(stream, "%d", (word_t)IMM);
00639           break;
00640         default:
00641           /* anything unrecognized, e.g., '.' is just passed through */
00642           fputc(*s, stream);
00643         }
00644         s++;
00645       }
00646     }
00647 }

void md_print_ireg (  md_gpr_t    regs,
int    reg,
FILE *    stream
) 
 

Definition at line 445 of file alpha.c.

References md_reg_name(), and myfprintf(). 

00446 {
00447   myfprintf(stream, "%4s: %16ld/0x%012lx",
00448             md_reg_name(rt_gpr, reg), regs[reg], regs[reg]);
00449 }

void md_print_iregs (  md_gpr_t    regs,
FILE *    stream
) 
 

Definition at line 452 of file alpha.c.

References md_print_ireg(). 

00453 {
00454   int i;
00455 
00456   for (i=0; i < MD_NUM_IREGS; i += 2)
00457     {
00458       md_print_ireg(regs, i, stream);
00459       fprintf(stream, "  ");
00460       md_print_ireg(regs, i+1, stream);
00461       fprintf(stream, "\n");
00462     }
00463 }

char* md_reg_name (  enum md_reg_type    rt,
int    reg
) 
 

Definition at line 325 of file alpha.c.

References md_reg_names_t::file, md_reg_names_t::reg, and md_reg_names_t::str. 

00326 {
00327   int i;
00328 
00329   for (i=0; md_reg_names[i].str != NULL; i++)
00330     {
00331       if (md_reg_names[i].file == rt && md_reg_names[i].reg == reg)
00332         return md_reg_names[i].str;
00333     }
00334 
00335   /* no found... */
00336   return NULL;
00337 }

char* md_reg_obj (  struct regs_t *    regs,
int    is_write,
enum md_reg_type    rt,
int    reg,
struct eval_value_t *    val
) 
 

Definition at line 340 of file alpha.c.

References md_fpr_t::d, et_addr, et_double, eval_as_addr(), eval_as_double(), md_ctrl_t::fpcr, panic(), md_fpr_t::q, regs_t::regs_C, regs_t::regs_F, regs_t::regs_NPC, regs_t::regs_PC, regs_t::regs_R, eval_value_t::type, md_ctrl_t::uniq, and eval_value_t::value. 

00345 {
00346   switch (rt)
00347     {
00348     case rt_gpr:
00349       if (reg < 0 || reg >= MD_NUM_IREGS)
00350         return "register number out of range";
00351 
00352       if (!is_write)
00353         {
00354           val->type = et_qword;
00355           val->value.as_qword = regs->regs_R[reg];
00356         }
00357       else
00358         regs->regs_R[reg] = eval_as_qword(*val);
00359       break;
00360 
00361     case rt_lpr:
00362       if (reg < 0 || reg >= MD_NUM_FREGS)
00363         return "register number out of range";
00364 
00365       if (!is_write)
00366         {
00367           val->type = et_qword;
00368           val->value.as_qword = regs->regs_F.q[reg];
00369         }
00370       else
00371         regs->regs_F.q[reg] = eval_as_qword(*val);
00372       break;
00373 
00374     case rt_fpr:
00375       if (reg < 0 || reg >= MD_NUM_FREGS)
00376         return "register number out of range";
00377 
00378       if (!is_write)
00379         {
00380           val->type = et_double;
00381           val->value.as_double = regs->regs_F.d[reg];
00382         }
00383       else
00384         regs->regs_F.d[reg] = eval_as_double(*val);
00385       break;
00386 
00387     case rt_ctrl:
00388       switch (reg)
00389         {
00390         case /* FPCR */0:
00391           if (!is_write)
00392             {
00393               val->type = et_qword;
00394               val->value.as_qword = regs->regs_C.fpcr;
00395             }
00396           else
00397             regs->regs_C.fpcr = eval_as_qword(*val);
00398           break;
00399 
00400         case /* UNIQ */1:
00401           if (!is_write)
00402             {
00403               val->type = et_qword;
00404               val->value.as_qword = regs->regs_C.uniq;
00405             }
00406           else
00407             regs->regs_C.uniq = eval_as_qword(*val);
00408           break;
00409 
00410         default:
00411           return "register number out of range";
00412         }
00413       break;
00414 
00415     case rt_PC:
00416       if (!is_write)
00417         {
00418           val->type = et_addr;
00419           val->value.as_addr = regs->regs_PC;
00420         }
00421       else
00422         regs->regs_PC = eval_as_addr(*val);
00423       break;
00424 
00425     case rt_NPC:
00426       if (!is_write)
00427         {
00428           val->type = et_addr;
00429           val->value.as_addr = regs->regs_NPC;
00430         }
00431       else
00432         regs->regs_NPC = eval_as_addr(*val);
00433       break;
00434 
00435     default:
00436       panic("bogus register bank");
00437     }
00438 
00439   /* no error */
00440   return NULL;
00441 }

word_t md_xor_regs (  struct regs_t *    regs ) 
 

Definition at line 519 of file alpha.c.

References md_ctrl_t::fpcr, md_fpr_t::q, regs_t::regs_C, regs_t::regs_F, regs_t::regs_NPC, regs_t::regs_PC, regs_t::regs_R, and md_ctrl_t::uniq. 

00520 {
00521   int i;
00522   qword_t checksum = 0;
00523 
00524   for (i=0; i < (MD_NUM_IREGS-1); i++)
00525     checksum ^= regs->regs_R[i];
00526 
00527   for (i=0; i < (MD_NUM_FREGS-1); i++)
00528     checksum ^= regs->regs_F.q[i];
00529 
00530   checksum ^= regs->regs_C.fpcr;
00531   checksum ^= regs->regs_C.uniq;
00532   checksum ^= regs->regs_PC;
00533   checksum ^= regs->regs_NPC;
00534 
00535   return (word_t)((checksum >> 32) ^ checksum);
00536 }

Variable Documentation

char* md_amode_str[md_amode_NUM]
 

Initial value:

{
  "(const)",            
  "(gp + const)",       
  "(sp + const)",       
  "(fp + const)",       
  "(reg + const)",      
  "(reg + reg)"         
}

Definition at line 181 of file alpha.c.

char* md_fu2name[NUM_FU_CLASSES]
 

Initial value:

 {
  NULL, 
  "fu-int-ALU",
  "fu-int-multiply",
  "fu-int-divide",
  "fu-FP-add/sub",
  "fu-FP-comparison",
  "fu-FP-conversion",
  "fu-FP-multiply",
  "fu-FP-divide",
  "fu-FP-sqrt",
  "rd-port",
  "wr-port"
}

Definition at line 166 of file alpha.c.

enum md_opcode md_mask2op[MD_MAX_MASK+1]
 

Definition at line 117 of file alpha.c.

md_inst_t MD_NOP_INST = 0x43ff041f
 

Definition at line 114 of file alpha.c.

unsigned int md_op2flags[OP_MAX]
 

Initial value:

 {
  NA, 
#define DEFINST(OP,MSK,NAME,OPFORM,RES,FLAGS,O1,O2,I1,I2,I3) 
#define DEFLINK(OP,MSK,NAME,MASK,SHIFT) 
#define CONNECT(OP)

}

Definition at line 540 of file alpha.c.

char* md_op2format[OP_MAX]
 

Initial value:

 {
  NULL, 
#define DEFINST(OP,MSK,NAME,OPFORM,RES,FLAGS,O1,O2,I1,I2,I3) 
#define DEFLINK(OP,MSK,NAME,MASK,SHIFT) 
#define CONNECT(OP)

}

Definition at line 148 of file alpha.c.

enum md_fu_class md_op2fu[OP_MAX]
 

Initial value:

 {
  FUClamd_NA, 
#define DEFINST(OP,MSK,NAME,OPFORM,RES,FLAGS,O1,O2,I1,I2,I3) 
#define DEFLINK(OP,MSK,NAME,MASK,SHIFT) 
#define CONNECT(OP)

}

Definition at line 157 of file alpha.c.

char* md_op2name[OP_MAX]
 

Initial value:

 {
  NULL, 
#define DEFINST(OP,MSK,NAME,OPFORM,RES,FLAGS,O1,O2,I1,I2,I3) 
#define DEFLINK(OP,MSK,NAME,MASK,SHIFT) 
#define CONNECT(OP)

}

Definition at line 139 of file alpha.c.

unsigned int md_opmask[OP_MAX]
 

Initial value:

 {
  0, 
#define DEFINST(OP,MSK,NAME,OPFORM,RES,FLAGS,O1,O2,I1,I2,I3) 
#define DEFLINK(OP,MSK,NAME,SHIFT,MASK) 
#define CONNECT(OP)

}

Definition at line 121 of file alpha.c.

unsigned int md_opoffset[OP_MAX]
 

Definition at line 118 of file alpha.c.

unsigned int md_opshift[OP_MAX]
 

Initial value:

 {
  0, 
#define DEFINST(OP,MSK,NAME,OPFORM,RES,FLAGS,O1,O2,I1,I2,I3) 
#define DEFLINK(OP,MSK,NAME,SHIFT,MASK) 
#define CONNECT(OP)

}

Definition at line 130 of file alpha.c.

struct md_reg_names_t md_reg_names[]
 

Definition at line 192 of file alpha.c.


UVa CS Department of Computer Science
School of Engineering, University of Virginia
151 Engineer's Way, P.O. Box 400740
Charlottesville, Virginia 22904-4740
(434) 982-2200  Fax: (434) 982-2214