Open64: osprey/common/com/irbdata.h Source File

00001 /*
00002  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /*
00006 
00007   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00008 
00009   This program is free software; you can redistribute it and/or modify it
00010   under the terms of version 2 of the GNU General Public License as
00011   published by the Free Software Foundation.
00012 
00013   This program is distributed in the hope that it would be useful, but
00014   WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00016 
00017   Further, this software is distributed without any warranty that it is
00018   free of the rightful claim of any third person regarding infringement 
00019   or the like.  Any license provided herein, whether implied or 
00020   otherwise, applies only to this software file.  Patent licenses, if 
00021   any, provided herein do not apply to combinations of this program with 
00022   other software, or any other product whatsoever.  
00023 
00024   You should have received a copy of the GNU General Public License along
00025   with this program; if not, write the Free Software Foundation, Inc., 59
00026   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00027 
00028   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00029   Mountain View, CA 94043, or:
00030 
00031   http://www.sgi.com
00032 
00033   For further information regarding this notice, see:
00034 
00035   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00036 
00037 */
00038 
00039 
00040 /* -*-Mode: c++;-*- (Tell emacs to use c++ mode) */
00041 
00042 #ifndef irbdata_INCLUDED
00043 #define irbdata_INCLUDED
00044 
00045 /* ====================================================================
00046  * Module: irbdata.h
00047  * $Revision: 1.1.1.1 $
00048  * $Date: 2005/10/21 19:00:00 $
00049  * $Author: marcel $
00050  * $Source: /proj/osprey/CVS/open64/osprey1.0/common/com/irbdata.h,v $
00051  *
00052  * Revision history:
00053  *  21-Mar-93 - Original Version
00054  *
00055  * Description:
00056  * declaration of the initialized data structures
00057  * ==================================================================== */
00058 
00059 
00060 #ifndef symtab_INCLUDED
00061 #include "symtab.h"     // for Scope_tab
00062 #endif
00063 
00064 #ifndef irbdata_defs_INCLUDED
00065 #include "irbdata_defs.h"
00066 #endif
00067 
00068 // access functions for INITO
00069 
00070 inline ST_IDX
00071 INITO_st_idx (const INITO& inito) { return inito.st_idx; }
00072 inline void
00073 Set_INITO_st_idx (INITO& inito, ST_IDX st) { inito.st_idx = st; }
00074 inline void
00075 Set_INITO_st_idx (INITO_IDX idx, ST_IDX st) 
00076     { Set_INITO_st_idx(Inito_Table[idx], st); }
00077 inline ST*
00078 INITO_st (const INITO& ino)   { return &St_Table[ino.st_idx]; }
00079 inline ST*
00080 INITO_st (const INITO* ino)   { return &St_Table[ino->st_idx]; }
00081 inline ST*
00082 INITO_st (const INITO_IDX idx)    { return &St_Table[Inito_Table[idx].st_idx]; }
00083 
00084 inline INITV_IDX
00085 INITO_val (const INITO& inito)    { return inito.val; }
00086 inline INITV_IDX
00087 INITO_val (INITO_IDX idx)   { return INITO_val (Inito_Table[idx]);}
00088 inline void
00089 Set_INITO_val (INITO& ino, INITV_IDX inv) { ino.val = inv; }
00090 inline void
00091 Set_INITO_val (INITO_IDX idx, INITV_IDX inv)
00092     { Set_INITO_val(Inito_Table[idx], inv); }
00093 
00094 
00095 // access functions for INITV
00096 
00097 // read access for INITV
00098 
00099 inline INITV_IDX
00100 INITV_next (const INITV& initv)   { return initv.next; }
00101 inline INITV_IDX
00102 INITV_next (const INITV_IDX idx)  { return Initv_Table[idx].next; }
00103 
00104 inline void
00105 Set_INITV_next(const INITV_IDX idx, const INITV_IDX nidx) 
00106 {
00107   Initv_Table[idx].next = nidx; 
00108 }
00109 
00110 /*ARGSUSED*/ 
00111 inline void
00112 INITV_read_check (BOOL condition)
00113 {
00114     Is_True (condition, ("INITV read access error"));
00115 }
00116 
00117 inline INITVKIND
00118 INITV_kind (const INITV& initv)   { return initv.kind; }
00119 inline INITVKIND
00120 INITV_kind (const INITV_IDX idx)  { return Initv_Table[idx].kind; }
00121 
00122 inline UINT16
00123 INITV_repeat1 (const INITV& initv) {
00124 #ifdef Is_True_On
00125     switch (initv.kind) {
00126     case INITVKIND_ZERO:
00127     case INITVKIND_ONE:
00128     case INITVKIND_VAL:
00129       INITV_read_check (FALSE);
00130       break;
00131     default:
00132       break;
00133     }
00134 #endif  /* Is_True_On */
00135 
00136     return initv.repeat1;
00137 }
00138 
00139 inline UINT32
00140 INITV_repeat2 (const INITV& initv) {
00141 #ifdef Is_True_On
00142     switch (initv.kind) {
00143     case INITVKIND_ZERO:
00144     case INITVKIND_ONE:
00145     case INITVKIND_VAL:
00146       break;
00147     default:
00148       INITV_read_check (FALSE);
00149       break;
00150     }
00151 #endif
00152 
00153     return initv.Repeat2 ();
00154 }
00155 
00156 inline UINT32
00157 INITV_repeat (const INITV_IDX inv)
00158 {
00159   switch (Initv_Table[inv].kind) {
00160   case INITVKIND_VAL:
00161   case INITVKIND_ZERO:
00162   case INITVKIND_ONE:
00163     return Initv_Table[inv].u.tcval.repeat2;
00164   default:
00165     return Initv_Table[inv].repeat1;
00166   }
00167 }
00168 
00169 inline ST_IDX
00170 INITV_st (const INITV& initv) {
00171 #ifdef TARG_IA64
00172     INITV_read_check ((initv.kind == INITVKIND_SYMOFF) ||
00173           (initv.kind == INITVKIND_SYMIPLT));
00174 #else
00175     INITV_read_check (initv.kind == INITVKIND_SYMOFF);
00176 #endif
00177     return initv.St ();
00178 }
00179 inline ST_IDX
00180 INITV_st (const INITV_IDX initv) {
00181 #ifdef TARG_IA64
00182     INITV_read_check ((Initv_Table[initv].kind == INITVKIND_SYMOFF) ||
00183           (Initv_Table[initv].kind == INITVKIND_SYMIPLT));
00184 #else
00185     INITV_read_check (Initv_Table[initv].kind == INITVKIND_SYMOFF);
00186 #endif
00187     return Initv_Table[initv].St ();
00188 }
00189 inline void
00190 Set_INITV_st (INITV_IDX inv, ST_IDX st)
00191 {
00192 #ifdef TARG_IA64
00193     INITV_read_check (Initv_Table[inv].kind == INITVKIND_SYMOFF ||
00194           Initv_Table[inv].kind == INITVKIND_SYMIPLT);
00195 #else
00196     INITV_read_check (Initv_Table[inv].kind == INITVKIND_SYMOFF);
00197 #endif
00198     Initv_Table[inv].u.sto.st = st;
00199 }
00200   
00201 inline INT32
00202 INITV_ofst (const INITV& initv) {
00203 #ifdef TARG_IA64
00204     INITV_read_check (initv.kind == INITVKIND_SYMOFF || 
00205           initv.kind == INITVKIND_SYMIPLT);
00206 #else
00207     INITV_read_check (initv.kind == INITVKIND_SYMOFF);
00208 #endif
00209     return initv.Ofst ();
00210 }
00211 inline INT32
00212 INITV_ofst (const INITV_IDX initv) {
00213 #ifdef TARG_IA64
00214     INITV_read_check (Initv_Table[initv].kind == INITVKIND_SYMOFF ||
00215           Initv_Table[initv].kind == INITVKIND_SYMIPLT);
00216 #else
00217     INITV_read_check (Initv_Table[initv].kind == INITVKIND_SYMOFF);
00218 #endif
00219     return Initv_Table[initv].Ofst ();
00220 }
00221 inline void
00222 Set_INITV_ofst (INITV_IDX inv, INT32 ofst)
00223 {
00224 #ifdef TARG_IA64
00225     INITV_read_check (Initv_Table[inv].kind == INITVKIND_SYMOFF ||
00226           Initv_Table[inv].kind == INITVKIND_SYMIPLT);
00227 #else
00228     INITV_read_check (Initv_Table[inv].kind == INITVKIND_SYMOFF);
00229 #endif
00230     Initv_Table[inv].u.sto.ofst = ofst;
00231 }
00232 
00233 inline LABEL_IDX
00234 INITV_lab (const INITV& initv) {
00235     INITV_read_check (initv.kind == INITVKIND_LABEL);
00236     return initv.Lab ();
00237 }
00238 inline LABEL_IDX
00239 INITV_lab (const INITV_IDX initv) {
00240     return INITV_lab (Initv_Table[initv]);
00241 }
00242 inline INT16
00243 INITV_lab_flags (const INITV& initv) {
00244     INITV_read_check (initv.kind == INITVKIND_LABEL);
00245     return initv.Lab_flags ();
00246 }
00247 inline INT16
00248 INITV_lab_flags (const INITV_IDX initv) {
00249     return INITV_lab_flags (Initv_Table[initv]);
00250 }
00251 inline mTYPE_ID
00252 INITV_lab_mtype (const INITV& initv) {
00253     INITV_read_check (initv.kind == INITVKIND_LABEL);
00254     return initv.Lab_mtype();
00255 }
00256 inline mTYPE_ID
00257 INITV_lab_mtype (const INITV_IDX initv) {
00258     return INITV_lab_mtype (Initv_Table[initv]);
00259 }
00260 inline void
00261 Set_INITV_lab (INITV& inv, LABEL_IDX lab) { 
00262   inv.u.lab.lab = lab;
00263   inv.u.lab.flags = INITVLABELFLAGS_UNUSED;
00264         inv.u.lab.mtype = MTYPE_UNKNOWN;
00265 }
00266 inline void
00267 Set_INITV_lab (INITV_IDX inv, LABEL_IDX lab) { 
00268     INITV_read_check (Initv_Table[inv].kind == INITVKIND_LABEL);
00269     Set_INITV_lab(Initv_Table[inv], lab); 
00270 }
00271 
00272 inline LABEL_IDX
00273 INITV_lab1 (const INITV& initv) {
00274     INITV_read_check (initv.kind == INITVKIND_SYMDIFF ||
00275           initv.kind == INITVKIND_SYMDIFF16);
00276     return initv.Lab1 ();
00277 }
00278 inline LABEL_IDX
00279 INITV_lab1 (const INITV_IDX initv) {
00280     return INITV_lab1 (Initv_Table[initv]);
00281 }
00282 inline void
00283 Set_INITV_lab1 (INITV& inv, LABEL_IDX lab1) { 
00284   inv.u.stdiff.lab1 = lab1;
00285 }
00286 inline void
00287 Set_INITV_lab1 (INITV_IDX inv, LABEL_IDX lab1) { 
00288     INITV_read_check (Initv_Table[inv].kind == INITVKIND_SYMDIFF ||
00289           Initv_Table[inv].kind == INITVKIND_SYMDIFF16);
00290     Set_INITV_lab1(Initv_Table[inv], lab1); 
00291 }
00292 
00293 inline ST_IDX
00294 INITV_st2 (const INITV& initv) {
00295     INITV_read_check (initv.kind == INITVKIND_SYMDIFF ||
00296           initv.kind == INITVKIND_SYMDIFF16);
00297     return initv.St2 ();
00298 }
00299 inline ST_IDX
00300 INITV_st2 (const INITV_IDX initv) {
00301     return INITV_st2 (Initv_Table[initv]);
00302 }
00303 inline void
00304 Set_INITV_st2 (INITV_IDX inv, ST_IDX st2) { 
00305     INITV_read_check (Initv_Table[inv].kind == INITVKIND_SYMDIFF ||
00306           Initv_Table[inv].kind == INITVKIND_SYMDIFF16);
00307     Initv_Table[inv].u.stdiff.st2 = st2;
00308 }
00309 
00310 inline TCON_IDX
00311 INITV_tc (const INITV& initv) {
00312     INITV_read_check (initv.kind == INITVKIND_VAL);
00313     return initv.Tc ();
00314 }
00315 inline TCON&
00316 INITV_tc_val (const INITV& initv) {
00317     INITV_read_check (initv.kind == INITVKIND_VAL);
00318     return Tcon_Table[initv.Tc ()];
00319 }
00320 inline TCON&
00321 INITV_tc_val (const INITV_IDX initv) {
00322     INITV_read_check (Initv_Table[initv].kind == INITVKIND_VAL);
00323     return Tcon_Table[Initv_Table[initv].Tc ()];
00324 }
00325 
00326 inline TYPE_ID
00327 INITV_mtype (const INITV& initv) {
00328     INITV_read_check (initv.kind == INITVKIND_ZERO ||
00329           initv.kind == INITVKIND_ONE);
00330     return initv.Mtype ();
00331 }
00332 inline TYPE_ID
00333 INITV_mtype (const INITV_IDX initv) {
00334     INITV_read_check (Initv_Table[initv].kind == INITVKIND_ZERO ||
00335           Initv_Table[initv].kind == INITVKIND_ONE);
00336     return Initv_Table[initv].Mtype ();
00337 }
00338 
00339 #ifdef KEY
00340 inline mINT32
00341 INITV_flags (const INITV& initv) {
00342     INITV_read_check (initv.kind == INITVKIND_BLOCK);
00343     return initv.u.blk.flags;
00344 }
00345 
00346 inline void
00347 Set_INITV_flags (INITV& initv, mINT32 flags) {
00348     INITV_read_check (initv.kind == INITVKIND_BLOCK);
00349     initv.u.blk.flags = flags;
00350 }
00351 
00352 inline void
00353 Set_INITV_flags (INITV_IDX initv, mINT32 flags) {
00354     Set_INITV_flags (Initv_Table[initv], flags);
00355 }
00356 #endif // KEY
00357 
00358 inline INITV_IDX
00359 INITV_blk (const INITV& initv) {
00360     INITV_read_check (initv.kind == INITVKIND_BLOCK);
00361     return initv.Blk ();
00362 }
00363 inline INITV_IDX
00364 INITV_blk (const INITV_IDX initv) {
00365   return INITV_blk(Initv_Table[initv]);
00366 }
00367 inline void
00368 Set_INITV_blk (INITV& inv, INITV_IDX blk) { 
00369   inv.u.blk.blk = blk;
00370 #ifdef KEY
00371   inv.u.blk.flags = 0;
00372 #else
00373   inv.u.blk.unused = 0;
00374 #endif // KEY
00375 }
00376 inline void
00377 Set_INITV_blk (INITV_IDX inv, INITV_IDX blk) { 
00378   Set_INITV_blk(Initv_Table[inv], blk); 
00379 }
00380 
00381 inline INT32
00382 INITV_pad (const INITV& initv) {
00383     INITV_read_check (initv.kind == INITVKIND_PAD);
00384     return initv.Pad ();
00385 }
00386 inline INT32
00387 INITV_pad (const INITV_IDX initv) {
00388     INITV_read_check (Initv_Table[initv].kind == INITVKIND_PAD);
00389     return Initv_Table[initv].Pad ();
00390 }
00391 inline void
00392 Set_INITV_pad (INITV& initv, UINT32 pad_bytes) {
00393    initv.u.pad.pad = pad_bytes;
00394 }
00395 
00396 
00397 // utility functions
00398 
00399 extern INITO_IDX
00400 New_INITO (ST_IDX st, INITV_IDX val = 0);
00401 inline INITO_IDX
00402 New_INITO (const ST *st, INITV_IDX val = 0) {
00403     return New_INITO (ST_st_idx (st), val);
00404 }
00405 
00406 extern INITV_IDX New_INITV (void);
00407 
00408 extern INITV_IDX
00409 Copy_INITV (INITV_IDX parent_inv, INITO_IDX ino, INITV_IDX inv);
00410 
00411 extern void
00412 INITV_Init_Integer (INITV_IDX inv, 
00413   TYPE_ID mtype, INT64 val, UINT16 repeat = 1);
00414 
00415 extern void
00416 INITV_Init_Float (INITV_IDX inv, TYPE_ID mtype, double val, UINT16 repeat = 1);
00417 
00418 extern void
00419 INITV_Init_String (INITV_IDX inv, char *str, INT size, UINT16 repeat = 1);
00420 
00421 extern void
00422 INITV_Init_Symoff (INITV_IDX inv, ST *st, INT64 ofst, UINT16 repeat = 1);
00423 
00424 #ifdef TARG_IA64
00425 extern void
00426 INITV_Init_Symiplt (INITV_IDX inv, ST *st, INT64 ofst, UINT16 repeat = 1);
00427 #endif
00428 extern void
00429 INITV_Init_Label (INITV_IDX inv, LABEL_IDX lab, UINT16 repeat = 1, INT16 flags = INITVLABELFLAGS_UNUSED, mTYPE_ID mtype = MTYPE_UNKNOWN);
00430 
00431 extern void
00432 INITV_Init_Symdiff (INITV_IDX inv, 
00433   LABEL_IDX lab1, ST *st2, BOOL halfword, UINT16 repeat = 1);
00434 
00435 extern void
00436 #ifdef KEY
00437 INITV_Init_Block (INITV_IDX inv, INITV_IDX bval, UINT16 repeat = 1, mINT32 flags = 0);
00438 #else
00439 INITV_Init_Block (INITV_IDX inv, INITV_IDX bval, UINT16 repeat = 1);
00440 #endif // KEY
00441 
00442 extern void
00443 INITV_Init_Pad (INITV_IDX inv, UINT32 pad_bytes);
00444 
00445 // append inv either as child of ino or as next sibling of prev_inv
00446 inline INITV_IDX
00447 Append_INITV (INITV_IDX inv, INITO_IDX ino, INITV_IDX prev_inv)
00448 {
00449   if (prev_inv == INITV_IDX_ZERO)
00450       Set_INITO_val (ino, inv);
00451   else
00452       Set_INITV_next (prev_inv, inv);
00453   return inv;
00454 }
00455 
00456 // return the next to-be-allocated INITV_IDX
00457 inline INITV_IDX
00458 INITV_Next_Idx(void) { return Initv_Table.Size(); }
00459 
00460 // return total size of initvs under inito
00461 extern UINT
00462 Get_INITO_Size (INITO_IDX ino);
00463 
00464 extern INITO_IDX
00465 Find_INITO_For_Symbol (const ST *st);
00466 
00467 extern void
00468 Print_INITV (const INITV& initv);
00469 
00470 extern void
00471 Print_INITV_idx (const INITV_IDX inv_idx);
00472 
00473 extern void
00474 Print_INITVs (INITV_IDX initv);
00475 
00476 extern void
00477 Print_INITO (const INITO& ino);
00478 inline void
00479 Print_INITO (INITO_IDX idx) { Print_INITO(Inito_Table[idx]); }
00480 
00481 extern void
00482 Print_Inits (UINT level);
00483 
00484 
00485 // internal inline routines for writing INITV
00486 
00487 inline void
00488 INITV_Set_SYMOFF (INITV& initv, mUINT16 rp1, ST_IDX st, INT32 ofst) {
00489     initv.next = 0;
00490     initv.kind = INITVKIND_SYMOFF;
00491     initv.repeat1 = rp1;
00492     initv.u.sto.st = st;
00493     initv.u.sto.ofst = ofst;
00494 }
00495 
00496 #ifdef TARG_IA64
00497 inline void
00498 INITV_Set_SYMIPLT (INITV& initv, mUINT16 rp1, ST_IDX st, INT32 ofst) {
00499     initv.next = 0;
00500     initv.kind = INITVKIND_SYMIPLT;
00501     initv.repeat1 = rp1;
00502     initv.u.sto.st = st;
00503     initv.u.sto.ofst = ofst;
00504 }
00505 #endif
00506 
00507 inline void
00508 INITV_Set_LABEL (INITV& initv, mUINT16 rp1, LABEL_IDX lab, INT16 flags = INITVLABELFLAGS_UNUSED, mTYPE_ID mtype = MTYPE_UNKNOWN) {
00509     initv.next = 0;
00510     initv.kind = INITVKIND_LABEL;
00511     initv.repeat1 = rp1;
00512     initv.u.lab.lab = lab;
00513     initv.u.lab.flags = flags;
00514     initv.u.lab.mtype = mtype;
00515 }
00516 
00517 inline void
00518 INITV_Set_int (INITV& initv, INITVKIND kind, TYPE_ID m, UINT32 rp2) {
00519     initv.next = 0;
00520     initv.kind = kind;
00521     initv.repeat1 = 0;
00522     initv.u.tcval.u.mtype = m;
00523     initv.u.tcval.repeat2 = rp2;
00524 }
00525 inline void
00526 INITV_Set_ZERO (INITV& initv, TYPE_ID m, UINT32 rp2) {
00527     INITV_Set_int (initv, INITVKIND_ZERO, m, rp2);
00528 }
00529 inline void
00530 INITV_Set_ONE (INITV& initv, TYPE_ID m, UINT32 rp2) {
00531     INITV_Set_int (initv, INITVKIND_ONE, m, rp2);
00532 }
00533 
00534 inline void
00535 INITV_Set_VAL (INITV& initv, TCON_IDX t, mUINT32 rp2) {
00536     initv.next = 0;
00537     initv.kind = INITVKIND_VAL;
00538     initv.repeat1 = 0;
00539     initv.u.tcval.u.tc = t;
00540     initv.u.tcval.repeat2 = rp2;
00541 }
00542 
00543 inline void
00544 #ifndef KEY
00545 INITV_Set_BLOCK (INITV& initv, mUINT16 rp1, INITV_IDX b) {
00546 #else
00547 INITV_Set_BLOCK (INITV& initv, mUINT16 rp1, INITV_IDX b, mINT32 flags=0) {
00548 #endif
00549     initv.next = 0;
00550     initv.kind = INITVKIND_BLOCK;
00551     initv.repeat1 = rp1;
00552     initv.u.blk.blk = b;
00553 #ifndef KEY
00554     initv.u.blk.unused = 0;
00555 #else
00556     initv.u.blk.flags = flags;
00557 #endif // !KEY
00558 }
00559 
00560 inline void
00561 INITV_Set_PAD (INITV& initv, UINT32 pad_bytes) {
00562     initv.next = 0;
00563     initv.kind = INITVKIND_PAD;
00564     initv.repeat1 = 1;
00565     initv.u.pad.pad = pad_bytes;
00566     initv.u.pad.unused = 0;
00567 }
00568 
00569 inline void
00570 INITV_Set_SYMDIFF (INITV& initv, mUINT16 rp1, LABEL_IDX s1, ST_IDX s2,
00571        BOOL halfword) 
00572 { 
00573     initv.next = 0;
00574     initv.kind = halfword ? INITVKIND_SYMDIFF16 : INITVKIND_SYMDIFF;
00575     initv.repeat1 = rp1;
00576     initv.u.stdiff.lab1 = s1;
00577     initv.u.stdiff.st2 = s2;
00578 }
00579     
00580 
00581 
00582 // old routines here for compatibility; should eventually remove
00583 
00584 extern INITV_IDX
00585 Irb_Init_Symoff (INITO_IDX ino, INITV_IDX inv, mUINT16 repeat, ST *st,
00586      INT64 ofst);
00587      
00588 extern INITV_IDX
00589 Irb_Init_Label (INITO_IDX ino, INITV_IDX inv, mUINT16 repeat, LABEL_IDX lab);
00590 
00591 extern INITV_IDX
00592 Irb_Init_Symdiff (INITO_IDX ino, INITV_IDX inv, mUINT16 repeat, LABEL_IDX lab1,
00593       ST *st2, BOOL halfword);
00594 
00595 extern INITV_IDX
00596 Irb_Init_Val (INITO_IDX ino, INITV_IDX inv, UINT32 repeat, TCON_IDX tc);
00597 
00598 extern INITV_IDX
00599 Irb_Init_Pad (INITO_IDX ino, INITV_IDX inv, UINT32 pad_bytes);
00600 
00601 extern INITV_IDX
00602 Irb_Init_Block (INITO_IDX ino, INITV_IDX inv, mUINT16 repeat);
00603 
00604 extern INITV_IDX
00605 Irb_Init_Integer (INT size, INT64 value, INT32 repeat, INITO_IDX ino,
00606       INITV_IDX inv); 
00607      
00608 extern INITV_IDX
00609 Irb_Init_Integer_Of_Type (TYPE_ID mtype, INT64 value, INT32 repeat,
00610         INITO_IDX ino, INITV_IDX inv);   
00611      
00612 extern INITV_IDX
00613 Irb_Init_String (INT size, char *str, INT32 repeat, INITO_IDX ino,
00614      INITV_IDX inv);
00615 
00616 #ifndef MONGOOSE_BE
00617 
00618 extern INITV_IDX
00619 Irb_Init_Float (INT size, double value, INT32 repeat, INITO_IDX ino,
00620     INITV_IDX inv);
00621 
00622 extern INITV_IDX
00623 Irb_Init_Float_4 (INT size, float value, INT32 repeat, INITO_IDX ino,
00624       INITV_IDX inv);
00625 
00626 extern INITV_IDX
00627 Irb_Init_Quad (INT size, QUAD_TYPE value, INT32 repeat, INITO_IDX ino,
00628          INITV_IDX inv);
00629 
00630 extern INITV_IDX
00631 Irb_Init_Complex (INT size, double real, double imag, INT32 repeat,
00632       INITO_IDX ino, INITV_IDX inv);
00633 
00634 extern INITV_IDX
00635 Irb_Init_Complex_4 (INT size, float real, float imag, INT32 repeat,
00636         INITO_IDX ino, INITV_IDX inv);
00637 
00638 extern INITV_IDX
00639 Irb_Init_Complex_Quad (INT size, QUAD_TYPE real, QUAD_TYPE imag,
00640            INT32 repeat, INITO_IDX ino, INITV_IDX inv);
00641 
00642 #endif /* MONGOOSE_BE */
00643 
00644 #endif /* irbdata_INCLUDED */