Open64: osprey/libkapi/kapi_save_source

00001 /*
00002  * Copyright (c) 2000, Intel Corporation
00003  * All rights reserved.
00004  *
00005  * WARRANTY DISCLAIMER
00006  *
00007  * THESE MATERIALS ARE PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00008  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
00009  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00010  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS 
00011  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00012  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00013  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
00014  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
00015  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
00016  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THESE
00017  * MATERIALS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00018  *
00019  * Intel Corporation is the author of the Materials, and requests that all
00020  * problem reports or change requests be submitted to it directly at
00021  * http://developer.intel.com/opensource.
00022  */
00023 
00024 #include <stdio.h>
00025 #include <stdlib.h>
00026 #include <assert.h>
00027 #include <string.h>
00028 #include <malloc.h>
00029 #include "kapi_internal.h"
00030 #include "kapi_parse.h"
00031 #include "kapi_util.h"
00032 #include "kapi_error.h"
00033 #include "kapi_save_source_ia64.h"
00034 
00035 
00036 /**********************************************************
00037 Various utilities for saving (adding commas, int->str etc.)
00038 ***********************************************************/
00039 /* global for reference in multiple functions */
00040 char *FieldNames[enum_LAST_KAPI_FIELD];
00041 
00042 
00043 /* Macros & globals */
00044 /*-----------*/
00045 
00046 #define API_VER_STR "4_0"
00047 
00048 
00049 #include "kapi_saver_utils.h"
00050 
00051 
00052 
00053 /***************************************************************
00054 ia64 information saving functions
00055 ****************************************************************/
00056 
00057 
00058 void KAPI_save_as_header_MachineDescription_struct( FILE *fp, knobs_t *pknobs ,char *pchName, FILE *fpTables)
00059 {
00060    int  i;
00061    char *myName;
00062    char pchTmp[200];
00063    FILE *fpTmp=tmpfile();
00064    char *mpCacheNames[cache_type_enum_size];
00065    /* Sanity */
00066   assert(NULL!=fp);
00067   assert(NULL!=pknobs);
00068   assert(NULL!=pchName);
00069 
00070 
00071    /* Assign Names */
00072   myName=make_string_attach(pchName,API_VER_STR);
00073   FieldNames[enum_mpclrTable]=make_string_attach(myName,"cluster_info");
00074   FieldNames[enum_pfSaveHeaderFlags]=make_string_attach(myName,"saved_fields_info");
00075   FieldNames[enum_dmpfuinfoTable]=make_string_attach(myName,"fu_info");
00076   FieldNames[enum_dmpebyInterTable]=make_string_attach(myName,"intercluster_bypass_info");
00077   FieldNames[enum_dmpabyIntraTable]=make_string_attach(myName,"intracluster_bypass_info");
00078   FieldNames[enum_mppportinfoTable]=make_string_attach(myName,"port_info");
00079   FieldNames[enum_dmpinstTable]=make_string_attach(myName,"instruction_info");
00080   FieldNames[enum_dmpitinfoTable]=make_string_attach(myName,"it_info");
00081   FieldNames[enum_dmpbidinfoTable]=make_string_attach(myName,"bundle_info");
00082   FieldNames[enum_dmpsylinfoTable]=make_string_attach(myName,"syl_info");
00083   FieldNames[enum_dmpcacheTable]=make_string_attach(myName,"cache_info");
00084 
00085 
00086 
00087     /* Save tables */
00088   /* ----------- */
00089   /* tables will be saved in fpTables */
00090 
00091   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_pfSaveHeaderFlags],"knobs_fields_enum_t", FieldNames[enum_pfSaveHeaderFlags],enum_LAST_KAPI_FIELD,
00092     pknobs->pfSaveHeaderFlags,KAPI_save_as_header_saver_flags);
00093   ADD_PTR_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_mppportinfoTable],"cportinfo_t", FieldNames[enum_mppportinfoTable],pknobs->nports,
00094     pknobs->mppportinfoTable,KAPI_save_as_header_PortInfo_struct);
00095   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpebyInterTable],"eby_t", FieldNames[enum_dmpebyInterTable],pknobs->nRawInter,
00096     pknobs->dmpebyInterTable,KAPI_save_as_header_InterClusterBypassInfo_struct);
00097   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpabyIntraTable],"aby_t", FieldNames[enum_dmpabyIntraTable],pknobs->nRawIntra,
00098     pknobs->dmpabyIntraTable,KAPI_save_as_header_IntraClusterBypassInfo_struct);
00099   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpfuinfoTable],"fuinfo_t", FieldNames[enum_dmpfuinfoTable],pknobs->nfuinfoTable,
00100     pknobs->dmpfuinfoTable,KAPI_save_as_header_FunctionalUnitInfo_struct);
00101   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpinstTable],"inst_t", FieldNames[enum_dmpinstTable],pknobs->ninstTable,
00102     pknobs->dmpinstTable,KAPI_save_as_header_InstructionInfo_struct);
00103   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpitinfoTable],"itinfo_t", FieldNames[enum_dmpitinfoTable],pknobs->nitinfoTable,
00104     pknobs->dmpitinfoTable,KAPI_save_as_header_InstructionTypeInfo_struct);
00105   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpbidinfoTable],"bidinfo_t", FieldNames[enum_dmpbidinfoTable],pknobs->nbidinfoTable,
00106     pknobs->dmpbidinfoTable,KAPI_save_as_header_BundleInfo_struct);
00107   ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpsylinfoTable],"sylinfo_t", FieldNames[enum_dmpsylinfoTable],pknobs->nsylinfoTable,
00108     pknobs->dmpsylinfoTable,KAPI_save_as_header_SyllableInfo_struct);
00109   for (i=0;i<cache_type_enum_size;i++){
00110     *pchTmp='\0';
00111     sprintf(pchTmp,"%d",i);
00112     mpCacheNames[i]=make_string_attach(FieldNames[enum_dmpcacheTable],pchTmp);
00113     ADD_STRUCT_ARRAY_ON_FLAG(pknobs->pfSaveHeaderFlags[enum_dmpcacheTable],"cache_t",mpCacheNames[i] ,pknobs->nCacheLevels[i],
00114       pknobs->dmpcacheTable[i],KAPI_save_as_header_Cache_struct);
00115   }
00116 
00117    /* Save structure */
00118    /* -------------- */
00119    /* First append all the tables in the temporary file to the tables file */
00120    append_tmp(fpTables,fpTmp);
00121    /* structures will be saved in fp */ 
00122    fpTmp=fp;
00123 
00124    ADD_COMMENT("General info, always saved");
00125    KAPI_save_as_header_name_list(fp,FieldNames[enum_pfSaveHeaderFlags]);
00126    ADD_COMMENT("Bundle issue width info");
00127    KAPI_save_as_header_int_array_list(fp,pknobs->maxBundleIssue,maxCLR);
00128    ADD_COMMENT("Instruction issue width info");
00129    KAPI_save_as_header_int_array_list(fp,pknobs->maxInstructionIssue,maxCLR);
00130    ADD_COMMENT("misc parsing info, never saved (fImplicitNone,cntLinesDeltaFile,cntLinesBaselineFile");
00131    for (i=0;i<3;i++)
00132   KAPI_save_as_header_int_list(fp,0);
00133    ADD_COMMENT("Tool:");
00134    KAPI_save_as_header_String_list(fp,pknobs->pchToolname);
00135    ADD_NEWLINE;
00136 
00137    /* Cluster info */
00138    ADD_COMMENT("nClusters");
00139    KAPI_save_as_header_int_list(fp,pknobs->nclr);
00140    ADD_NEWLINE;
00141    ADD_COMMENT("Cluster Info:");
00142    ADD_NEWLINE;
00143    START_ARRAY;
00144    SAVE_STRUCT_ARRAY(maxCLR,pknobs->mpclrTable,
00145      KAPI_save_as_header_ClusterInfo_struct,FieldNames[enum_mpclrTable]);
00146    CLOSE_ARRAY;
00147    ADD_COMMA;
00148    ADD_NEWLINE;
00149    ADD_COMMENT("Intercluster bypass info");
00150    ADD_COMMENT("Entries,Table Name:");
00151    KAPI_save_as_header_int_list(fp,pknobs->nRawInter);
00152    KAPI_save_as_header_name_list(fp,FieldNames[enum_dmpebyInterTable]);
00153    ADD_NEWLINE;
00154    ADD_COMMENT("IntraCluster bypass info");
00155    ADD_COMMENT("Entries,Table Name:");
00156    KAPI_save_as_header_int_list(fp,pknobs->nRawIntra);
00157    KAPI_save_as_header_name_list(fp,FieldNames[enum_dmpabyIntraTable]);
00158    ADD_NEWLINE;
00159    /* Ports info (global) */
00160    ADD_COMMENT("port info");
00161    ADD_COMMENT("global:");
00162    KAPI_save_as_header_int_list(fp,pknobs->nports);
00163    START_STRUCT;
00164    for (i=0;i<(maxPORTS);i++)
00165    {
00166      *pchTmp='\0';
00167      if ((NULL==pknobs->mppportinfoTable[i]) || (0==pknobs->pfSaveHeaderFlags[enum_mppportinfoTable]))
00168        sprintf(pchTmp,"NULL");
00169      else
00170        sprintf(pchTmp,"&(%s[%d])",FieldNames[enum_mppportinfoTable],i);
00171      KAPI_save_as_header_name(fp,pchTmp);
00172      if (i<(maxPORTS-1)) ADD_COMMA;
00173    }
00174    CLOSE_STRUCT;
00175    ADD_COMMA;
00176    ADD_NEWLINE;
00177    ADD_COMMENT("port to cluster mapping");
00178    KAPI_save_as_header_int_array_list(fp,pknobs->port2cluster,32);
00179    ADD_NEWLINE;
00180    ADD_COMMENT("global unit type information (number of units of each type)");
00181    KAPI_save_as_header_int_array_list(fp,pknobs->mpnut,kapi_nUT);
00182    ADD_NEWLINE;
00183    /*fu's & instructions information */
00184    ADD_COMMENT("fu info");
00185    ADD_COMMENT("Entries,Table Name:");
00186    KAPI_save_as_header_int_list(fp,pknobs->nfuinfoTable);
00187    KAPI_save_as_header_name_list(fp,FieldNames[enum_dmpfuinfoTable]);
00188    ADD_NEWLINE;
00189    ADD_COMMENT("instruction information");
00190    ADD_COMMENT("Entries,Table Name:");
00191    KAPI_save_as_header_int_list(fp,pknobs->ninstTable);
00192    KAPI_save_as_header_name_list(fp,FieldNames[enum_dmpinstTable]);
00193    ADD_NEWLINE;
00194    ADD_COMMENT("instruction type information");
00195    ADD_COMMENT("Entries,Table Name:");
00196    KAPI_save_as_header_int_list(fp,pknobs->nitinfoTable);
00197    KAPI_save_as_header_name_list(fp,FieldNames[enum_dmpitinfoTable]);
00198    ADD_NEWLINE;
00199    ADD_COMMENT("bundle information");
00200    ADD_COMMENT("Entries,Table Name:");
00201    KAPI_save_as_header_int_list(fp,pknobs->nbidinfoTable);
00202    KAPI_save_as_header_name_list(fp,FieldNames[enum_dmpbidinfoTable]);
00203    ADD_NEWLINE;
00204    ADD_COMMENT("syllable information");
00205    ADD_COMMENT("Entries,Table Name:");
00206    KAPI_save_as_header_int_list(fp,pknobs->nsylinfoTable);
00207    KAPI_save_as_header_name_list(fp,FieldNames[enum_dmpsylinfoTable]);
00208    ADD_NEWLINE;
00209    ADD_COMMENT("cache info:");
00210    KAPI_save_as_header_int_array_list(fp,pknobs->nCacheLevels,cache_type_enum_size);
00211    START_ARRAY;
00212    for (i=0;i<cache_type_enum_size;i++) {
00213      KAPI_save_as_header_name(fp,mpCacheNames[i]);
00214      if (i<cache_type_enum_size-1) ADD_COMMA;
00215    }
00216    CLOSE_ARRAY;
00217    ADD_COMMA;
00218 
00219 
00220    /* symbol table information, never saved */
00221 /*  struct _SYM_TABLE_NODE *dmpstn; 
00222   int nstn;
00223   int fRestructuredAttributes;
00224   struct _VALUE_NODE *pvalnTypeList;   
00225   struct _VALUE_NODE *pvalnVarList;    
00226   struct _VALUE_NODE *pvalnAttrList;   
00227 */
00228    KAPI_save_as_header_name_list(fp,"NULL");
00229    KAPI_save_as_header_int_list(fp,0);
00230    KAPI_save_as_header_int_list(fp,0);
00231    KAPI_save_as_header_name_list(fp,"NULL");
00232    KAPI_save_as_header_name_list(fp,"NULL");
00233    KAPI_save_as_header_name(fp,"NULL");
00234    ADD_NEWLINE;
00235    /* cleanup */
00236   free(myName);
00237   free(FieldNames[enum_mpclrTable]);
00238   free(FieldNames[enum_pfSaveHeaderFlags]);
00239   free(FieldNames[enum_dmpfuinfoTable]);
00240   free(FieldNames[enum_dmpebyInterTable]);
00241   free(FieldNames[enum_dmpabyIntraTable]);
00242   free(FieldNames[enum_mppportinfoTable]);
00243   free(FieldNames[enum_dmpinstTable]);
00244   free(FieldNames[enum_dmpitinfoTable]);
00245   free(FieldNames[enum_dmpbidinfoTable]);
00246   free(FieldNames[enum_dmpsylinfoTable]);
00247   for (i=0;i<cache_type_enum_size;i++)
00248     free(mpCacheNames[i]);
00249 
00250 }
00251 
00252 void KAPI_save_as_header_saver_flags(FILE *fp,knobs_t *pknobs,int *pFlag, char *pchName, FILE *fpTables)
00253 {
00254   FILE *fpTmp=fp;
00255   KAPI_save_as_header_int(fp,*pFlag);
00256 }
00257 
00258 void KAPI_save_as_header_ClusterInfo_struct(FILE *fp,knobs_t *pknobs,clr_t *pclr,char *pchName, FILE *fpTables)
00259 {
00260   int i;
00261   FILE *fpTmp=tmpfile();
00262   char *myName;
00263   char *PortTableNames[kapi_nUT];
00264   char pchTmp[200];
00265     kapi_ut_t ut;
00266     kapi_cutport_t icutport;
00267 
00268 
00269   /* Sanity */
00270   /* Init Names */
00271   *pchTmp='\0';
00272   sprintf(pchTmp,"%d",pclr->idxclr);
00273   myName=make_string_attach(pchName,pchTmp);
00274   if (0!=pknobs->pfSaveHeaderFlags[enum_mpclrTable])
00275   {
00276     for (i=0;i<kapi_nUT;i++)
00277     {
00278       *pchTmp='\0';
00279       sprintf(pchTmp,"ut%d",i);
00280       PortTableNames[i]=make_string_attach(myName,pchTmp);
00281     }
00282     /* Save Related Tables */
00283     for (i=0;i<(kapi_nUT);i++)
00284     {
00285       if (pclr->mpncutport[i]>0) {
00286         ADD_STRUCT_ARRAY("cportinfo_t", PortTableNames[i],pclr->mpncutport[i],
00287           pclr->dmppcportinfoTable[i],KAPI_save_as_header_PortInfo_struct);
00288       } else
00289         ADD_NULL_PTR("cportinfo_t", PortTableNames[i]);
00290     }
00291   }
00292 
00293   /* Save Struct */
00294    append_tmp(fpTables,fpTmp);
00295    fpTmp=fp;
00296 
00297    if (0==pknobs->pfSaveHeaderFlags[enum_mpclrTable])
00298      ADD_COMMENT("Dummy entry for fixed sized array");
00299    /* cluster number */
00300   ADD_COMMENT("id:");
00301   KAPI_save_as_header_int_list(fp,pclr->idxclr);
00302    /* number of ports in cluster and ports info*/
00303   ADD_COMMENT("ncports");
00304   KAPI_save_as_header_int_list(fp,pclr->ncports);
00305    /* 1d array of pointers to structures */
00306   ADD_COMMENT("ports:");
00307   START_ARRAY;
00308     for (i=0;i<(maxCPORTS);i++)
00309   {
00310      *pchTmp='\0';
00311 
00312      if ((NULL==pclr->mppcportinfoTable[i]) || (0==pknobs->pfSaveHeaderFlags[enum_mpclrTable]))
00313        sprintf(pchTmp,"NULL");
00314      else
00315      {
00316        ut=pclr->mppcportinfoTable[i]->ut;
00317        icutport=pclr->mppcportinfoTable[i]->cutport;
00318        sprintf(pchTmp,"&(%s[%d])",PortTableNames[ut],icutport);
00319      }
00320      KAPI_save_as_header_name(fp,pchTmp);
00321      if (i<(maxCPORTS-1)) ADD_COMMA;
00322   }
00323   CLOSE_ARRAY;
00324     ADD_COMMA;
00325   ADD_NEWLINE;
00326    /* 2d array of cport structures, length of 2nd D in mpncutport */
00327   START_ARRAY;
00328     for (i=0;i<(kapi_nUT);i++)
00329    {
00330      *pchTmp='\0';
00331      if (NULL==pclr->dmppcportinfoTable[i] || (0==pknobs->pfSaveHeaderFlags[enum_mpclrTable]))
00332        sprintf(pchTmp,"NULL");
00333      else
00334        sprintf(pchTmp,"%s",PortTableNames[i]);
00335      KAPI_save_as_header_name(fp,pchTmp);
00336      if (i<(kapi_nUT-1)) ADD_COMMA;
00337    }
00338   CLOSE_ARRAY;
00339     ADD_COMMA;
00340   ADD_COMMENT("size of 2nd D for the 2D array above");
00341   KAPI_save_as_header_int_array_list(fp,pclr->mpncutport,kapi_nUT);
00342    /* cport to global port mapping */
00343     KAPI_save_as_header_int_array_list(fp,pclr->cport2port,32);
00344    /* distance to other clr */
00345     KAPI_save_as_header_int_array(fp,pclr->distClr,maxCLR);
00346   ADD_NEWLINE;
00347   /* cleanup */
00348   for (i=0;i<kapi_nUT;i++)
00349     free(PortTableNames[i]);
00350   free(myName);
00351 }
00352 
00353 void KAPI_save_as_header_InterClusterBypassInfo_struct(FILE *fp,knobs_t *pknobs,eby_t *peby,char *pchName,FILE *fpTables)
00354 {
00355   FILE *fpTmp=fp;
00356   /* Inter Cluster Bypass Info: */
00357   ADD_COMMENT("clrSrc");
00358   KAPI_save_as_header_int_list(fp,peby->clusterSrc);
00359   ADD_COMMENT("clrDest");
00360   KAPI_save_as_header_int_list(fp,peby->clusterDest);
00361   ADD_COMMENT("fuSrc");
00362   KAPI_save_as_header_int_list(fp,peby->fuSrc);
00363   ADD_COMMENT("fuDest");
00364   KAPI_save_as_header_int_list(fp,peby->fuDest);
00365   ADD_COMMENT("cutportSrc");
00366   KAPI_save_as_header_int_list(fp,peby->cutportSrc);
00367   ADD_COMMENT("cutportDest");
00368   KAPI_save_as_header_int_list(fp,peby->cutportDest);
00369   ADD_COMMENT("utSrc");
00370   KAPI_save_as_header_int_list(fp,peby->utSrc);
00371   ADD_COMMENT("utDest");
00372   KAPI_save_as_header_int_list(fp,peby->utDest);
00373   ADD_COMMENT("oppSrc");
00374   KAPI_save_as_header_int_list(fp,peby->oppSrc);
00375   ADD_COMMENT("oppDest");
00376   KAPI_save_as_header_int_list(fp,peby->oppDest);
00377   ADD_COMMENT("Value");
00378   KAPI_save_as_header_int(fp,peby->iValue);
00379   ADD_NEWLINE;
00380 }
00381 
00382 void KAPI_save_as_header_IntraClusterBypassInfo_struct(FILE *fp,knobs_t *pknobs,aby_t *paby, char *pchName,FILE *fpTables)
00383 {
00384   FILE *fpTmp=fp;
00385   /* Intra Cluster Bypass Info: */
00386   ADD_COMMENT("clr:");
00387   KAPI_save_as_header_int_list(fp,paby->cluster);
00388   ADD_COMMENT("fuSrc");
00389   KAPI_save_as_header_int_list(fp,paby->fuSrc);
00390   ADD_COMMENT("fuDest");
00391   KAPI_save_as_header_int_list(fp,paby->fuDest);
00392   ADD_COMMENT("cutportSrc");
00393   KAPI_save_as_header_int_list(fp,paby->cutportSrc);
00394   ADD_COMMENT("cutportDest");
00395   KAPI_save_as_header_int_list(fp,paby->cutportDest);
00396   ADD_COMMENT("utSrc");
00397   KAPI_save_as_header_int_list(fp,paby->utSrc);
00398   ADD_COMMENT("utDest");
00399   KAPI_save_as_header_int_list(fp,paby->utDest);
00400   ADD_COMMENT("oppSrc");
00401   KAPI_save_as_header_int_list(fp,paby->oppSrc);
00402   ADD_COMMENT("oppDest");
00403   KAPI_save_as_header_int_list(fp,paby->oppDest);
00404   ADD_COMMENT("Value");
00405   KAPI_save_as_header_int_list(fp,paby->iValue);
00406   ADD_COMMENT("Entry");
00407     KAPI_save_as_header_String(fp,paby->pchEntry);
00408   ADD_NEWLINE;
00409 }
00410 
00411 void KAPI_save_as_header_PortInfo_struct(FILE *fp,knobs_t *pknobs,cportinfo_t *pcport,char *pchName,FILE *fpTables)
00412 {
00413   FILE *fpTmp=fpTables;
00414   char *myName=NULL;
00415 
00416   fpTmp=fp;
00417   ADD_COMMENT("port(ut,cp,cut):");
00418   KAPI_save_as_header_int_list(fp,pcport->ut);
00419   KAPI_save_as_header_int_list(fp,pcport->cport);
00420   KAPI_save_as_header_int_list(fp,pcport->cutport);
00421   ADD_COMMENT("bv-fu:");
00422   SAVE_STRUCT(KAPI_save_as_header_BitVector_struct(fp,
00423     &(pcport->bvfuAllowed),
00424     myName,fpTables));
00425 }
00426 
00427 void KAPI_save_as_header_FunctionalUnitInfo_struct(FILE *fp,knobs_t *pknobs,fuinfo_t *pfut,char *pchName,FILE *fpTables)
00428 {
00429   FILE *fpTmp=fp;
00430   char comment[50];
00431   sprintf(comment,"fu: %s",pfut->pchName);
00432   ADD_COMMENT(comment);
00433   KAPI_save_as_header_int_list(fp,pfut->fu);
00434   ADD_COMMENT("core latencies");
00435   KAPI_save_as_header_int_array_list(fp,pfut->iCoreLatency,maxDESTINATIONS);
00436   ADD_COMMENT("ndests & dest names");
00437   KAPI_save_as_header_int_list(fp,pfut->cntDest);
00438   KAPI_save_as_header_String_array_list_always(fp,pfut->mppchDestName,pfut->cntDest);
00439   ADD_COMMENT("nsrcs & src names");
00440   KAPI_save_as_header_int_list(fp,pfut->cntSrc);
00441   KAPI_save_as_header_String_array_list_always(fp,pfut->mppchSrcName,pfut->cntSrc);
00442   KAPI_save_as_header_bv32_list(fp,pfut->bv32InfoBits);
00443     KAPI_save_as_header_String(fp,pfut->pchName);
00444 }
00445 
00446 void KAPI_save_as_header_InstructionInfo_struct(FILE *fp,knobs_t *pknobs,inst_t *pinst,char *pchName,FILE *fpTables)
00447 {
00448   FILE *fpTmp=fp;
00449 #ifdef ADD_INSTRUCTION_STRINGS
00450     KAPI_save_as_header_String_list_always(fp,pinst->pchUniqueName);
00451     KAPI_save_as_header_String_list_always(fp,pinst->pchMnemonic);
00452 #else
00453     KAPI_save_as_header_String_list(fp,pinst->pchUniqueName);
00454     KAPI_save_as_header_String_list(fp,pinst->pchMnemonic);
00455 #endif
00456     /* function unit class character representation */
00457   KAPI_save_as_header_String_list(fp,pinst->pchfu);
00458   /* it character representation */
00459     KAPI_save_as_header_String_list(fp,pinst->pchit);
00460   /* instruction type */
00461   ADD_COMMENT("it:");
00462   KAPI_save_as_header_int_list(fp,pinst->it);
00463   /* function unit restrictions/byp/latency */
00464   ADD_COMMENT("fu:");
00465     KAPI_save_as_header_int(fp,pinst->fu);
00466   ADD_NEWLINE;
00467 }
00468 
00469 void KAPI_save_as_header_InstructionTypeInfo_struct(FILE *fp,knobs_t *pknobs,itinfo_t *pit,char *pchName,FILE *fpTables)
00470 {
00471   FILE *fpTmp=fp;
00472   char *myName=NULL;
00473   ADD_COMMENT("it:");
00474   KAPI_save_as_header_int_list(fp,pit->it);
00475   ADD_COMMENT("Available:");
00476   KAPI_save_as_header_int_list(fp,pit->maxAvail);
00477     KAPI_save_as_header_String_list(fp,pit->pchitName);
00478   ADD_COMMENT("syllables allowed");
00479   /* bit vector 32bit == int! */
00480   KAPI_save_as_header_bv32(fp,pit->bv32sylAllowed);
00481   ADD_NEWLINE;
00482 }
00483 
00484 void KAPI_save_as_header_BundleInfo_struct(FILE *fp,knobs_t *pknobs,bidinfo_t *pbid,char *pchName,FILE *fpTables)
00485 {
00486   FILE *fpTmp=fp;
00487   /* syllables comprising this bundle type */
00488   ADD_COMMENT("syl types:");
00489   KAPI_save_as_header_int_array_list(fp,(int *)(pbid->mpsylType),nSYLBID);
00490   /* number of syllables of each type */
00491   ADD_COMMENT("available syls:");
00492   KAPI_save_as_header_int_array_list(fp,pbid->mpnsylAvail,kapi_nSYL);
00493   /* number of instructions of each type possible */
00494   ADD_COMMENT("available it's:");
00495   KAPI_save_as_header_int_array_list(fp,pbid->mpnitAvail,kapi_nIT);
00496   /* is this a reserved bid (flag) */
00497   ADD_COMMENT("flag:");
00498   KAPI_save_as_header_int_list(fp,pbid->fReserved);
00499   /* 0 == no sbit, 1, 2 legal values */
00500   ADD_COMMENT("stop bit slot:");
00501   KAPI_save_as_header_int_list(fp,pbid->isylSbit);
00502     /* string rep of expected bid */
00503     KAPI_save_as_header_String(fp,pbid->pchBID);
00504   ADD_NEWLINE;
00505 }
00506 
00507 void KAPI_save_as_header_SyllableInfo_struct(FILE *fp,knobs_t *pknobs,sylinfo_t *psyl, char *pchName,FILE *fpTables)
00508 {
00509   FILE *fpTmp=fp;
00510   /* number of syllables of each type */
00511   ADD_COMMENT("uts needed:");
00512   KAPI_save_as_header_int_array_list(fp,psyl->mpnutNeeded,kapi_nUT);
00513   ADD_COMMENT("it:");
00514   KAPI_save_as_header_int(fp,psyl->itMajor);
00515 }
00516 
00517 void KAPI_save_as_header_CachePortInfo_struct( FILE *fp, knobs_t *pknobs, cacheport_t *pcaport , char *pchName, FILE *fpTables)
00518 {
00519   FILE *fpTmp=fp;
00520 
00521   KAPI_save_as_header_bv32(fp,pcaport->bv32AccessMode);
00522 }
00523 
00524 void KAPI_save_as_header_Cache_struct( FILE *fp, knobs_t *pknobs, cache_t *pcache , char *pchName, FILE *fpTables)
00525 {
00526   FILE *fpTmp;
00527   char *myName;
00528   char pchTmp[200];
00529   int i;
00530   static int struct_num=0;
00531   
00532   /* init names */
00533   
00534   *pchTmp='\0';
00535   struct_num++;
00536   sprintf(pchTmp,"N_%d",struct_num);
00537   myName=make_string_attach(pchName,pchTmp);
00538   /* save struct */
00539   fpTmp=fp;
00540   ADD_COMMENT("nLines");
00541   KAPI_save_as_header_int_list(fp,pcache->nLines);
00542   ADD_COMMENT("nBytesLine");
00543   KAPI_save_as_header_int_list(fp,pcache->nBytesLine);
00544   ADD_COMMENT("nWays");
00545   KAPI_save_as_header_int_list(fp,pcache->nWays);
00546   ADD_NEWLINE;
00547   ADD_COMMENT("nCachePorts,portinfo array");
00548   KAPI_save_as_header_int_list(fp,pcache->nCachePorts);
00549   START_ARRAY;
00550     for (i=0;i<(KAPI_MAX_CACHE_PORTS_IMPL);i++)
00551    {
00552     KAPI_save_as_header_CachePortInfo_struct(fp,pknobs,&(pcache->cacheportInfo[i]),myName,fpTables);     
00553     if (i<(KAPI_MAX_CACHE_PORTS_IMPL-1)) ADD_COMMA;
00554    }
00555   CLOSE_ARRAY;
00556   ADD_COMMA;
00557   ADD_COMMENT("iWritePolicy");
00558   KAPI_save_as_header_int_list(fp,pcache->iWritePolicy);
00559   ADD_COMMENT("iReplPolicy");
00560   KAPI_save_as_header_int_list(fp,pcache->iReplPolicy);
00561   ADD_COMMENT("iAllocPolicy");
00562   KAPI_save_as_header_int(fp,pcache->iAllocPolicy);
00563   ADD_NEWLINE;
00564 }
00565 
00566 int KAPI_save_as_header_MachineDescription_saver( FILE *fp, void *pConfig , char *pchName, int *pfSaveFlags)
00567 {
00568   knobs_t *pknobs=(knobs_t *)pConfig;
00569   FILE *fpTmp=fp;
00570   FILE *fpTmpTablesFile=NULL;
00571   char pchVersion[200];
00572   char pchHeader[]="#include \"kapi_internal.h\"\n";
00573 
00574   /* sanity */
00575   if (NULL==fp) return -1;
00576   if (NULL==pConfig) 
00577   {
00578     ADD_COMMENT("no valid configuration\n");
00579     return -1;
00580   }
00581   if (NULL==pchName)
00582   {
00583     ADD_COMMENT("no name for saving ia64 structures\n");
00584     return -1;
00585   }
00586   /* prepare tmp files */
00587   fpTmp=tmpfile();//tmpfile();
00588   fpTmpTablesFile=tmpfile();//tmpfile();
00589   if ((NULL==fpTmp) || (NULL==fpTmpTablesFile))
00590     return -2;
00591   /* save the struct */
00592   pknobs->pfSaveHeaderFlags=pfSaveFlags;
00593   ADD_EXTERN_STRUCT_HEADER("knobs_t",pchName);
00594   KAPI_save_as_header_MachineDescription_struct( fpTmp, pknobs , pchName, fpTmpTablesFile);
00595   END_STRUCT;
00596   pknobs->pfSaveHeaderFlags=NULL;
00597   /* concat the tmp files and close them */
00598   fwrite(pchHeader,sizeof(char),strlen(pchHeader),fp);
00599   append_tmp(fp,fpTmpTablesFile);
00600   append_tmp(fp,fpTmp);
00601   /* save version for checks ...*/
00602   sprintf(pchVersion,"double %s_kapi_ia64_version = %#f\n;",pchName,KAPI_ia64_GetInternalVersion());
00603   return 0;
00604 }
00605 
00606 int KAPI_save_as_header_all_IA64_info( FILE *fp, void *pConfig , char *pchName)
00607 {
00608   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00609   int iRes;
00610   int i;
00611 
00612   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00613   /* set flags for all fields that need saving */
00614   for(i=0;i<enum_LAST_KAPI_FIELD;i++)
00615     pfSaveFlags[i]=1;
00616   /* save */
00617   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00618   /* free flags */
00619   return iRes;
00620 }
00621 
00622 int KAPI_save_as_header_latency_all_info( FILE *fp, void *pConfig , char *pchName)
00623 {
00624   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00625   int iRes;
00626   int i;
00627 
00628   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00629   pfSaveFlags[0]=1;
00630 
00631   /* set flags for all fields that need saving */
00632   for(i=enum_nclr;i<enum_dmpfuinfoTable;i++)
00633     pfSaveFlags[i]=1;
00634   /* save */
00635   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00636   return iRes;
00637 }
00638 int KAPI_save_as_header_latency_core_info( FILE *fp, void *pConfig , char *pchName)
00639 {
00640   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00641   int iRes;
00642   int i;
00643 
00644   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00645   /* set flags for all fields that need saving */
00646   for(i=enum_nfuinfoTable;i<enum_dmpfuinfoTable;i++)
00647     pfSaveFlags[i]=1;
00648   /* save */
00649   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00650   return iRes;
00651 }
00652 int  KAPI_save_as_header_cluster_all_info( FILE *fp, void *pConfig , char *pchName)
00653 {
00654   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00655   int iRes;
00656   int i;
00657 
00658   /* set flags for all fields that need saving */
00659   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00660   for(i=enum_nclr;i<enum_port2cluster;i++)
00661     pfSaveFlags[i]=1;
00662   /* save */
00663   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00664   return iRes;
00665 }
00666 int KAPI_save_as_header_cluster_distance_info( FILE *fp, void *pConfig , char *pchName)
00667 {
00668   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00669   int iRes;
00670   int i;
00671 
00672   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00673   /* set flags for all fields that need saving */
00674   for(i=enum_nclr;i<enum_mpclrTable;i++)
00675     pfSaveFlags[i]=1;
00676   /* save */
00677   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00678   return iRes;
00679 }
00680 int KAPI_save_as_header_cluster_intracluster_latency_info( FILE *fp, void *pConfig , char *pchName)
00681 {
00682   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00683   int iRes;
00684   int i;
00685 
00686   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00687   /* set flags for all fields that need saving */
00688   for(i=enum_nclr;i<enum_mpclrTable;i++)
00689     pfSaveFlags[i]=1;
00690   for(i=enum_nRawIntra;i<enum_dmpabyIntraTable;i++)
00691     pfSaveFlags[i]=1;
00692   /* save */
00693   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00694   return iRes;
00695 }
00696 int KAPI_save_as_header_cluster_intercluster_latency_info( FILE *fp, void *pConfig , char *pchName)
00697 {
00698   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00699   int iRes;
00700   int i;
00701 
00702   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00703   /* set flags for all fields that need saving */
00704   for(i=enum_nclr;i<enum_mpclrTable;i++)
00705     pfSaveFlags[i]=1;
00706   for(i=enum_nRawInter;i<enum_dmpebyInterTable;i++)
00707     pfSaveFlags[i]=1;
00708   /* save */
00709   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00710   return iRes;
00711 }
00712 int KAPI_save_as_header_functional_units_info_info( FILE *fp, void *pConfig , char *pchName)
00713 {
00714   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00715   int iRes;
00716   int i;
00717 
00718   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00719   /* set flags for all fields that need saving */
00720   for(i=enum_mpnut;i<enum_dmpfuinfoTable;i++)
00721     pfSaveFlags[i]=1;
00722   /* save */
00723   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00724   return iRes;
00725 }  
00726 int KAPI_save_as_header_instruction_all_info( FILE *fp, void *pConfig , char *pchName)
00727 {
00728   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00729   int iRes;
00730   int i;
00731 
00732   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00733   /* set flags for all fields that need saving */
00734   for(i=enum_ninstTable;i<enum_dmpsylinfoTable;i++)
00735     pfSaveFlags[i]=1;
00736   /* save */
00737   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00738   return iRes;
00739 }  
00740 int KAPI_save_as_header_instruction_type_info( FILE *fp, void *pConfig , char *pchName)
00741 {
00742   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00743   int iRes;
00744   int i;
00745 
00746   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00747   /* set flags for all fields that need saving */
00748   for(i=enum_nitinfoTable;i<enum_dmpitinfoTable;i++)
00749     pfSaveFlags[i]=1;
00750   /* save */
00751   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00752   return iRes;
00753 }  
00754 int KAPI_save_as_header_byd_n_syl_info( FILE *fp, void *pConfig , char *pchName)
00755 {
00756   int pfSaveFlags[enum_LAST_KAPI_FIELD];
00757   int iRes;
00758   int i;
00759 
00760   memset(pfSaveFlags,0,sizeof(int)*enum_LAST_KAPI_FIELD);
00761   /* set flags for all fields that need saving */
00762   for(i=enum_nbidinfoTable;i<enum_dmpsylinfoTable;i++)
00763     pfSaveFlags[i]=1;
00764   /* save */
00765   iRes=KAPI_save_as_header_MachineDescription_saver(fp,pConfig,pchName,pfSaveFlags);
00766   return iRes;
00767 }  
00768 int KAPI_fEnableIA64call_from_header(void **pConfig, void *pHeaderConfig, int iReserved)
00769 {
00770   if (NULL==pHeaderConfig)
00771     return -1;
00772   *pConfig=(knobs_t *)pHeaderConfig;
00773   return 0;
00774 }
00775
osprey/libkapi/kapi_save_source_ia64.c
