osprey/dipa/rta/rta.h

Go to the documentation of this file.

/*

  Copyright (C) 2008 .  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

  Further, this software is distributed without any warranty that it is
  free of the rightful claim of any third person regarding infringement 
  or the like.  Any license provided herein, whether implied or 
  otherwise, applies only to this software file.  Patent licenses, if 
  any, provided herein do not apply to combinations of this program with 
  other software, or any other product whatsoever.  

  You should have received a copy of the GNU General Public License along
  with this program; if not, write the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston MA 02111-1307, USA.

*/

#ifndef _RTA_H_
#define _RTA_H_

#include <inttypes.h>
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#define RTA_API static inline

typedef enum {
    RTA_DYNAMIC = 0x5a,
    RTA_STATIC = 1,
} RTA_TYPE;
typedef enum {
    V_0_9 = 0,
    V_1_0 = 0x0123456789abcdefLL
} RTA_MAGIC;
typedef enum { 
    RTA_X8664 = 0, RTA_X8632 = 1, 
    RTA_IA64 = 2, RTA_MIPS = 3,
} RTA_TARGET;

typedef enum {
    RTA_FREQUENT = 0,
    RTA_INFREQUENT = 1,
    RTA_FREQ_UNKNOWN = 2
} RTA_FREQ;

#define RTA_SCN_NAME_PREFIX  ".rta."
#define RTA_SCN_NAME_PREFIX_LEN 5
#define RTA_DATA_SCN_NAME    ".rta.data"
#define RTA_INDEX_SCN_NAME   ".rta.index"

typedef enum {
    RTA_EXTRA_UNKNOWN = 0,
    RTA_EXTRA_RESULT = 1,
    RTA_EXTRA_OPERAND = 2,
} RTA_EXTRA_TYPE;

typedef struct {
    UINT64 start;         
    UINT64 data_off;      
    UINT32 size;          
    char     padding[4];    
} Rta_Idx_Ent;

/* access functions */
RTA_API UINT64 Rta_idx_ent_start(const Rta_Idx_Ent *ent)  { return ent->start; }
RTA_API UINT64 Rta_idx_ent_data_off(const Rta_Idx_Ent *ent)  { return ent->data_off; }
RTA_API UINT32 Rta_idx_ent_size(const Rta_Idx_Ent *ent)  { return ent->size; }

RTA_API void Rta_idx_ent_set_start(Rta_Idx_Ent *ent, UINT64 start) {
    FmtAssert(ent, ("The pointer to Rta_Idx_Ent is NULL"));
    ent->start = start;
}
RTA_API void Rta_idx_ent_set_data_off(Rta_Idx_Ent *ent, UINT64 data_off) {
    FmtAssert(ent, ("The pointer to Rta_Idx_Ent is NULL"));
    ent->data_off = data_off;
}
RTA_API void Rta_idx_ent_set_size(Rta_Idx_Ent *ent, UINT32 size) {
    FmtAssert(ent, ("The pointer to Rta_Idx_Ent is NULL"));
    ent->size = size;
}

typedef struct {
    UINT64 magic;         
    INT32  pu_off;        
    UINT16 type;          
    UINT16 target;        
    UINT16 pu_num;        
    UINT16 flags;         
    char     padding[4];    
} Rta_Hdr;

/* access functions */
RTA_API RTA_MAGIC   Rta_hdr_magic(const Rta_Hdr *h)  { return (RTA_MAGIC)h->magic; }
RTA_API RTA_TYPE    Rta_hdr_type(const Rta_Hdr *h)   { return (RTA_TYPE)h->type; }
RTA_API RTA_TARGET  Rta_hdr_target(const Rta_Hdr *h) { return (RTA_TARGET)h->target; }
RTA_API INT32     Rta_hdr_pu_off(const Rta_Hdr *h) { return h->pu_off; }
RTA_API UINT16    Rta_hdr_pu_num(const Rta_Hdr *h) { return h->pu_num; }
RTA_API UINT16    Rta_hdr_flags(const Rta_Hdr *h)  { return h->flags; }

RTA_API void Rta_hdr_set_magic(Rta_Hdr *h, RTA_MAGIC magic) {
    FmtAssert(h, ("The pointer to Rta_Hdr is NULL"));
    h->magic = (UINT64)magic;
}
RTA_API void Rta_hdr_set_type(Rta_Hdr *h, RTA_TYPE type) {
    FmtAssert(h, ("The pointer to Rta_Hdr is NULL"));
    h->type = (UINT16)type;
}
RTA_API void Rta_hdr_set_target(Rta_Hdr *h, RTA_TARGET target) {
    FmtAssert(h, ("The pointer to Rta_Hdr is NULL"));
    h->target = (UINT16)target;
}
RTA_API void Rta_hdr_set_pu_off(Rta_Hdr *h, INT32 pu_off) {
    FmtAssert(h, ("The pointer to Rta_Hdr is NULL"));
    h->pu_off = pu_off;
}
RTA_API void Rta_hdr_set_pu_num(Rta_Hdr *h, UINT16 pu_num) {
    FmtAssert(h, ("The pointer to Rta_Hdr is NULL"));
    h->pu_num = pu_num;
}
RTA_API void Rta_hdr_set_flags(Rta_Hdr *h, UINT16 flags) {
    FmtAssert(h, ("The pointer to Rta_Hdr is NULL"));
    h->flags = flags;
}

typedef struct {
    UINT64   start;   
    UINT32   size;    
    UINT32   name;    
    INT32    bb_off;  
    INT32    cfg_off; 
    UINT32   maxregs; 
    UINT16   bb_num;  
    UINT16   bb_begin;
    UINT16   entry;   
    UINT16   exit;    
    UINT16   flags;   
    INT16    link;    
    //  char       padding[4];  //!< padding for 64bit alignment
} Rta_Pu;

/* access functions */
RTA_API UINT64 Rta_pu_start(const Rta_Pu *ph)    { return ph->start; }
RTA_API UINT32 Rta_pu_size(const Rta_Pu *ph)     { return ph->size; }
RTA_API UINT32 Rta_pu_name(const Rta_Pu *ph)     { return ph->name; }
RTA_API INT32  Rta_pu_bb_off(const Rta_Pu *ph)   { return ph->bb_off; }
RTA_API INT32  Rta_pu_cfg_off(const Rta_Pu *ph)  { return ph->cfg_off; }
RTA_API UINT16 Rta_pu_bb_num(const Rta_Pu *ph)   { return ph->bb_num; }
RTA_API UINT16 Rta_pu_bb_begin(const Rta_Pu *ph) { return ph->bb_begin; }
RTA_API UINT16 Rta_pu_entry(const Rta_Pu *ph)    { return ph->entry; }
RTA_API UINT16 Rta_pu_exit(const Rta_Pu *ph)     { return ph->exit; }
RTA_API UINT16 Rta_pu_flags(const Rta_Pu *ph)    { return ph->flags; }
RTA_API INT16  Rta_pu_link(const Rta_Pu *ph)     { return ph->link; }
RTA_API UINT32 Rta_pu_maxregs(const Rta_Pu *ph)  { return ph->maxregs; }

RTA_API void Rta_pu_set_start(Rta_Pu *ph, UINT64 start) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->start = start;
}
RTA_API void Rta_pu_set_size(Rta_Pu *ph, UINT32 size) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->size = size;
}
RTA_API void Rta_pu_set_name(Rta_Pu *ph, UINT32 name) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->name = name;
}
RTA_API void Rta_pu_set_bb_off(Rta_Pu *ph, INT32 bb_off) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->bb_off = bb_off;
}
RTA_API void Rta_pu_set_cfg_off(Rta_Pu *ph, INT32 cfg_off) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->cfg_off = cfg_off;
}
RTA_API void Rta_pu_set_bb_num(Rta_Pu *ph, UINT16 bb_num) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->bb_num = bb_num;
}
RTA_API void Rta_pu_set_bb_begin(Rta_Pu *ph, UINT16 bb_begin) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->bb_begin = bb_begin;
}
RTA_API void Rta_pu_set_entry(Rta_Pu *ph, UINT16 entry) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->entry = entry;
}
RTA_API void Rta_pu_set_exit(Rta_Pu *ph, UINT16 exit) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->exit = exit;
}
RTA_API void Rta_pu_set_flags(Rta_Pu *ph, UINT16 flags) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->flags = flags;
}
RTA_API void Rta_pu_set_link(Rta_Pu *ph, UINT16 link) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->link = link;
}
RTA_API void Rta_pu_set_maxregs(Rta_Pu *ph, UINT32 maxregs) {
    FmtAssert(ph, ("The pointer to Rta_Pu is NULL"));
    ph->maxregs = maxregs;
}

typedef struct {
    UINT32 start;      
    UINT32 size;       
    INT32  op_off;     
    UINT16 plink;      
    UINT16 slink;      
    UINT16 op_num;     
    UINT16 flags;      
    char     padding[4]; 
} Rta_Bb;

/* access functions */
RTA_API UINT32 Rta_bb_start(const Rta_Bb *bh)  { return bh->start; }
RTA_API UINT32 Rta_bb_size(const Rta_Bb *bh)   { return bh->size; }
RTA_API INT32  Rta_bb_op_off(const Rta_Bb *bh) { return bh->op_off; }
RTA_API UINT16 Rta_bb_plink(const Rta_Bb *bh)  { return bh->plink; }
RTA_API UINT16 Rta_bb_slink(const Rta_Bb *bh)  { return bh->slink; }
RTA_API UINT16 Rta_bb_op_num(const Rta_Bb *bh) { return bh->op_num; }
RTA_API UINT16 Rta_bb_flags(const Rta_Bb *bh)  { return bh->flags; }

RTA_API void Rta_bb_set_start(Rta_Bb *bh, UINT32 start) {
    FmtAssert(bh, ("The pointer to Rta_Bb is NULL"));
    bh->start = start;
}
RTA_API void Rta_bb_set_size(Rta_Bb *bh, UINT32 size) {
    FmtAssert(bh, ("The pointer to Rta_Bb is NULL"));
    bh->size = size;
}
RTA_API void Rta_bb_set_op_off(Rta_Bb *bh, INT32 op_off) {
    FmtAssert(bh, ("The pointer to Rta_Bb is NULL"));
    bh->op_off = op_off;
}
RTA_API void Rta_bb_set_plink(Rta_Bb *bh, UINT16 plink) {
    FmtAssert(bh, ("The pointer to Rta_Bb is NULL"));
    bh->plink = plink;
}
RTA_API void Rta_bb_set_slink(Rta_Bb *bh, UINT16 slink) {
    FmtAssert(bh, ("The pointer to Rta_Bb is NULL"));
    bh->slink = slink;
}
RTA_API void Rta_bb_set_op_num (Rta_Bb *bh, UINT16 op_num) {
    FmtAssert(bh, ("The pointer to Rta_Bb is NULL"));
    bh->op_num = op_num;
}
RTA_API void Rta_bb_set_flags(Rta_Bb *bh, UINT16 flags) {
    FmtAssert(bh, ("The pointer to Rta_Bb is NULL"));
    bh->flags = flags;
}

typedef UINT16 Rta_Edge;

const INT RTA_EDGE_BB_BITS = 14;

/* access functions */
RTA_API RTA_FREQ Rta_edge_freq(const Rta_Edge * num)  { return (RTA_FREQ)(*num>>RTA_EDGE_BB_BITS); }
RTA_API UINT16 Rta_edge_bb(const Rta_Edge * num)    { return *num & ((1<<RTA_EDGE_BB_BITS)-1); }

RTA_API Rta_Edge Rta_edge(RTA_FREQ freq, UINT16 bb) { return (freq<<RTA_EDGE_BB_BITS) + bb; }

typedef UINT16 Rta_Tn;

typedef struct {
    INT32  extra;         
    UINT16 opcode;        
    UINT16 result1;       
    UINT16 opnd1;         
    UINT16 opnd2;         
    UINT16 flags;         
    char     padding[2];    
} Rta_Op;

/* access functions */
RTA_API INT32  Rta_op_extra(const Rta_Op *op)   { return op->extra; }
RTA_API UINT16 Rta_op_opcode(const Rta_Op *op)  { return op->opcode; }
RTA_API Rta_Tn   Rta_op_result1(const Rta_Op *op) { return op->result1; }
RTA_API Rta_Tn   Rta_op_opnd1(const Rta_Op *op)   { return op->opnd1; }
RTA_API Rta_Tn   Rta_op_opnd2(const Rta_Op *op)   { return op->opnd2; }
RTA_API UINT16 Rta_op_flags(const Rta_Op *op)   { return op->flags; }

RTA_API void Rta_op_set_extra(Rta_Op *op, INT32 extra) {
    FmtAssert(op, ("The pointer to Rta_Op is NULL"));
    op->extra = extra;
}
RTA_API void Rta_op_set_opcode(Rta_Op *op, UINT16 opcode) {
    FmtAssert(op, ("The pointer to Rta_Op is NULL"));
    op->opcode = opcode;
}
RTA_API void Rta_op_set_result1(Rta_Op *op, Rta_Tn result1) {
    FmtAssert(op, ("The pointer to Rta_Op is NULL"));
    op->result1 = result1;
}
RTA_API void Rta_op_set_opnd1(Rta_Op *op, Rta_Tn opnd1) {
    FmtAssert(op, ("The pointer to Rta_Op is NULL"));
    op->opnd1 = opnd1;
}
RTA_API void Rta_op_set_opnd2(Rta_Op *op, Rta_Tn opnd2) {
    FmtAssert(op, ("The pointer to Rta_Op is NULL"));
    op->opnd2 = opnd2;
}
RTA_API void Rta_op_set_flags(Rta_Op *op, UINT16 flags) {
    FmtAssert(op, ("The pointer to Rta_Op is NULL"));
    op->flags = flags;
}

typedef struct {
    INT32  offset;        
    UINT16 type;          
    UINT16 flags;         
} Rta_Extra;

/* access functions */
RTA_API INT32        Rta_extra_offset(const Rta_Extra *ex)  { return ex->offset; }
RTA_API RTA_EXTRA_TYPE Rta_extra_type(const Rta_Extra *ex)    { return (RTA_EXTRA_TYPE)ex->type; }
RTA_API UINT16       Rta_extra_flags(const Rta_Extra *ex)   { return ex->flags & ((1<<15)-1); }
RTA_API BOOL           Rta_extra_last(const Rta_Extra *ex)    { return ex->flags & (1<<15); }

RTA_API void Rta_extra_set_offset(Rta_Extra *ex, INT32 offset) {
    FmtAssert(ex, ("The pointer to Rta_Extra is NULL"));
    ex->offset = offset;
}
RTA_API void Rta_extra_set_type(Rta_Extra *ex, RTA_EXTRA_TYPE type) {
    FmtAssert(ex, ("The pointer to Rta_Extra is NULL"));
    ex->type = (UINT16)type;
}
RTA_API void Rta_extra_set_flags(Rta_Extra *ex, UINT16 flags) {
    FmtAssert(ex, ("The pointer to Rta_Extra is NULL"));
    ex->flags &= 1<<15;
    ex->flags |= flags & ((1<<15)-1);
}
RTA_API void Rta_extra_set_last(Rta_Extra *ex, BOOL last) {
    FmtAssert(ex, ("The pointer to Rta_Extra is NULL"));
    if (last)
        ex->flags |= 1<<15;
    else
        ex->flags &= (1<<15)-1;
}

/* Iterator functions */
RTA_API Rta_Pu* Rta_pu_iter(Rta_Hdr* p) { return (Rta_Pu *)((char *)p + Rta_hdr_pu_off(p)); }
RTA_API Rta_Bb* Rta_bb_iter(Rta_Pu* p)  { return (Rta_Bb *)((char *)p + Rta_pu_bb_off(p)); }

/* Dump functions for each structure above */

void Print_rta_hdr(FILE *f, const Rta_Hdr *hdr, const char *indent);
void Print_rta_pu_title(FILE *f, const char *indent);
void Print_rta_pu(FILE *f, const Rta_Pu *pu, const char *indent);
void Print_rta_bb_title(FILE *f, const char *indent);
void Print_rta_bb(FILE *f, UINT64 pc, const Rta_Bb *bb, INT i, const char *indent);
void Print_rta_idx_ent(FILE *f, const Rta_Idx_Ent *ent, const char *indent);

#ifdef __cplusplus
} // end extern "C"
#endif

#endif // _RTA_H_

---