void dump_instruction_fus(FILE *fp, void *pknobs)
{
int num_of_insts,iid,dummy;
kapi_fu_t fu;
knobs_t *pIknobs;
typedef struct {
int x;
int *ix;
char *gogo;
int nx[2];
} xtest;
typedef struct {
int nxs;
xtest *pxtest;
xtest *ppx[2];
char *dx;
} ytest;
static int yy[]={5,5};
static xtest xx[]= {{2,yy,"gogo",{0,0}},
{2,yy,"gogo",{0,0}}};
static xtest zz[2]= {{2,yy,"gogo",{0,0}},
{2,yy,"gogo",{0,0}}};
static ytest ylast={2,
&(zz[1]),
{xx,zz},
"gugunza",
};
char *str;
char *cIdx;
char buffer[100];
int idx;
int iVal;
FILE *fpTab=fopen("tryTab.c","w");
int expressions=KAPI_EnumCardinality(pknobs,"expressions");
int i0,i1,m0,m1;
i0=KAPI_EnumIndex(pknobs,"port_t","portI0");
i1=KAPI_EnumIndex(pknobs,"port_t","portI1");
m0=KAPI_EnumIndex(pknobs,"port_t","portM0");
m1=KAPI_EnumIndex(pknobs,"port_t","portM1");
dummy=KAPI_cportMask4ut(pknobs,0,kapi_utI);
iVal=(1 << i0) | (1 << i1);
/* dummy=KAPI_portMask4ut(pknobs,0,kapi_utI); */
dummy=KAPI_cportMask4ut(pknobs,0,kapi_utM);
iVal=(1 << m0) | (1 << m1);
dummy=KAPI_cportMask4ut(pknobs,0,kapi_utF);
dummy=KAPI_cportMask4ut(pknobs,0,kapi_utB);
dummy=KAPI_fuCount(pknobs);
num_of_insts=KAPI_iidCount(pknobs);
_strset(buffer,0);
str="#include \"tryhead.h\"\n\ninst_info_tab_t infoTab[] = {\n";
fwrite(str,sizeof(char),strlen(str),fp);
for (iid=0;iid<num_of_insts;iid++)
{
_strset(buffer,0);
str=KAPI_iid2uniqueName(pknobs,iid,dummy);
fwrite(str,sizeof(char),strlen(str),fp);
fwrite(",",sizeof(char),1,fp);
fu=KAPI_iid2fu(pknobs,iid,dummy);
strcat(buffer,"/* ");
strcat(buffer,KAPI_fu2fuName(pknobs,fu,dummy));
strcat(buffer," */");
fwrite(buffer,sizeof(char),strlen(buffer),fp);
*buffer='\0';
_itoa(fu,buffer,10);
fwrite(buffer,sizeof(char),strlen(buffer),fp);
fwrite(",",sizeof(char),1,fp);
fwrite("\n",sizeof(char),1,fp);
}
_strset(buffer,0);
str="0,0\n};\n/*";
fwrite(str,sizeof(char),strlen(str),fp);
for (idx=0;idx<expressions;idx++)
{
*buffer='\0';
cIdx=KAPI_EnumName(pknobs,idx,"expressions");
iVal=KAPI_GetIntegerVariable(pknobs,"expr",idx);
sprintf(buffer,"[%s] = %d\n",cIdx,iVal);
fwrite(buffer,sizeof(char),strlen(buffer),fp);
}
_strset(buffer,0);
str="*/\n\n";
fwrite(str,sizeof(char),strlen(str),fp);
printf("finished Try\n");
fclose(fp);
fp=fopen("T1.c","w");
KAPI_save_as_header_all_IA64_info( fp, pknobs , "trying123");
printf("finished T1\n");
fclose(fp);
fclose(fpTab);
//KAPI_fEnableIA64call_from_header(&pknobs,&trying123,0);
fp=fopen("T2.c","w");
KAPI_save_as_header_all_IA64_info( fp, pknobs , "trying123");
fclose(fp);
printf("finished T2\n");
// pKmapiInfo=KMAPI_initialize(pknobs);
if (pKmapiInfo!=NULL)
printf("Kmapi initialized!\n");
else
{
printf("Kmapi Initialization Failed!\n");
}
//_getch();
}
/* Split issue format:
BID:T0:T1:<fu(fff,fff)>/<none>
where BID is bundle template,
T is yes or no, T0 indicating split before, T1 indicating split after
f is either * for any or a specific fuClass, indicating exception to the rule, or none
to indicate no execptions.
Currently only one syllable can contain exception.
Sample:
"bidMMB:no:yes:fu(* / * /fuBRP,* / * /fuNOP)"
*/
kmapi_result kmapi_parse_split(kmapi_knobs_t *pKMnobs,char *pchSplitRule,kapi_bid_t *pbid)
{
char *pchWalker;
char *pchRule;
char *pchBid;
char *pchTmp;
int iSlot=0;
kapi_bid_t bid;
bundle_fus_t *pbfu;
kapi_fu_t fu;
int fEND=FALSE;
pchRule=strdup(pchSplitRule);
pchBid=pchWalker=pchRule;
pchWalker=strchr(pchWalker,':');
*pchWalker='\0';
bid=KAPI_EnumIndex(pKMnobs->pKnobs,"bid_t",pchBid);
if (bid==-1)
{
kmapi_Error_pch1(0,"no such bundle template %s",pchBid);
return kmapi_failure;
}
pchTmp=++pchWalker;
pchWalker=strchr(pchWalker,':');
*pchWalker='\0';
if (strstr(pchTmp,"yes")!=NULL)
pKMnobs->dmpSplitRules[bid].bvSplits|=kmapi_implicit_break_before;
else
{
if (strstr(pchTmp,"no")==NULL)
{
kmapi_Error_pch1(0,"wrong format for split issue rule: %s",pchSplitRule);
return kmapi_failure;
}
}
pchTmp=++pchWalker;
pchWalker=strchr(pchWalker,':');
*pchWalker='\0';
if (strstr(pchTmp,"yes")!=NULL)
pKMnobs->dmpSplitRules[bid].bvSplits|=kmapi_implicit_break_after;
else
{
if (strstr(pchTmp,"no")==NULL)
{
kmapi_Error_pch1(0,"wrong format for split issue rule: %s",pchSplitRule);
return kmapi_failure;
}
}
pchWalker++;
if (strstr(pchWalker,"none")!=NULL)
return kmapi_success;
pchWalker=strchr(pchWalker,'(');
pchTmp=++pchWalker;
pbfu=bundle_fus_AddNode(&(pKMnobs->dmpSplitRules[bid].pSplitExeptions));
while (!fEND)
{
pchWalker++;
switch (*pchWalker)
{
case ')':
fEND=TRUE;
case '/':
*pchWalker='\0';
if (*pchTmp!='*')
{
fu=KAPI_EnumIndex(pKMnobs->pKnobs,"fu_t",pchTmp);
if (fu==-1) {
kmapi_Error_pch2(0,"No such fu %s in rule %s",pchTmp,pchSplitRule);
}
SETBIT_bv128(pbfu->bvSlots[iSlot],fu);
}
pchTmp=++pchWalker;
iSlot++;
break;
case ',':
*pchWalker='\0';
fu=KAPI_EnumIndex(pKMnobs->pKnobs,"fu_t",pchTmp);
SETBIT_bv128(pbfu->bvSlots[iSlot],fu);
pchTmp=++pchWalker;
iSlot=0;
pbfu=bundle_fus_AddNode(&(pKMnobs->dmpSplitRules[bid].pSplitExeptions));
break;
default:
break;
}
}
return kmapi_success;
}
int main( int argc, char *argv[] )
{
void *pvoid1;
FILE *fp1=NULL,*fp2=NULL;
FILE *outp=NULL;
FILE *Ferr=NULL;
char *toolname;
if (( (toolname=strrchr(argv[ 0],'\\')) ==NULL) &&
( (toolname=strrchr(argv[ 0],'/')) ==NULL) )
toolname=argv[ 0];
if ( argc < 2 ) {
printf("%s knobs toolname [delta knobs]\n", toolname );
exit(1);
}
if ( 5 <= argc )
freopen(argv[4],"w",stderr);
if ( 4 <= argc ) /*delta file exists*/
fp2 = fopen( argv[ 3 ], "r" );
fp1 = fopen( argv[ 1 ], "r" );
outp = fopen( "try.c", "w" );
if ((fp1==NULL) && (fp2==NULL))
{
printf("Could not open knobsfiles!\n");
return 2;
}
pvoid1 = KAPI_Initialize( fp2, fp1, argv[ 2 ]);
fclose( fp1 );
if (pvoid1!=NULL)
pvoid1=KAPI_ia64_Initialize(pvoid1);
if (NULL!=fp2) fclose( fp2 );
if ((5 <=argc ) && (NULL!=Ferr)) fclose( Ferr );
if ( pvoid1 ) {
int fuLD,tmp;
/*
KDebug_DumpMachineDescription( stdout, pvoid1, 0 );
KDebug_DumpInterClusterBypass( stdout, pvoid1 );
KDebug_DumpClusterDistances( stdout, pvoid1 );
KDebug_DumpIntraClusterBypass( stdout, pvoid1 );
KDebug_DumpLatencies( stdout, pvoid1 );
KDebug_DumpTotalLatency( stdout, pvoid1 );
printf( "fuLD has %d ports\n",
KAPI_cportCount4fu( pvoid1, -1, fuLD ) );
*/
fuLD = KAPI_EnumIndex( pvoid1, "fu_t", "fuLD" );
tmp = KAPI_IntraClusterBypass(pvoid1,0
,0,0,0,0,
7,0,0,0);
// dump_instruction_fus(outp,pvoid1);
KAPI_Finalize( pvoid1 );
} else {
fprintf( stderr, "KAPI_Initialize failed\n" );
}
#if 0
Test_bv128Rtns();
Test_bv64Rtns();
Test_bv32Rtns();
#endif
return 0;
}
