00001 #include "lego.H"
00002 #include <stdio.h>
00003 #include <string.h>
00004 #include <stl.h>
00005
00006
00007 legoOpcode *Opcode;
00008 FILE *fp;
00009
00010 void WriteDirective(legoOp *op)
00011 {
00012 attrList *alc;
00013 attrs *a;
00014 char *directive;
00015
00016 alc = op->GetOpAttrListPtr();
00017
00018 for(; alc != NULL; alc = alc->GetNextListPtr())
00019 {
00020 a = alc->GetAttrPtr();
00021 if(!a) continue;
00022
00023 if(a->GetAttrType() == ATTR_LC)
00024 {
00025 for(a = alc->GetAttrPtr(); a != NULL;
00026 a = a->GetNextLcEntryPtr())
00027 {
00028 if(strncmp(a->GetAttrString(),
00029 "directive:", 10) == 0)
00030 {
00031 directive = a->GetAttrString() +
00032 strlen("directive:");
00033 fprintf(fp, "\t%s", directive);
00034 }
00035 }
00036 }
00037
00038 }
00039 }
00040
00041 void WriteEndpDirective(legoProc *proc)
00042 {
00043 attrList *alc;
00044 attrs *a;
00045 char *directive;
00046
00047 alc = proc->GetRegionAttrListPtr();
00048
00049 for(; alc != NULL; alc = alc->GetNextListPtr())
00050 {
00051 a = alc->GetAttrPtr();
00052 if(!a) continue;
00053
00054 if(a->GetAttrType() == ATTR_LC)
00055 {
00056 for(a = alc->GetAttrPtr(); a != NULL;
00057 a = a->GetNextLcEntryPtr())
00058 {
00059 if(strncmp(a->GetAttrString(),
00060 "endp_directive:", 15) == 0)
00061 {
00062 directive = a->GetAttrString() +
00063 strlen("endp_directive:");
00064 fprintf(fp, "\t%s", directive);
00065 }
00066 }
00067 }
00068
00069 }
00070 }
00071
00072 void WriteJTBL(legoOp *op)
00073 {
00074 attrList *alc;
00075 attrs *a;
00076 char *directive;
00077
00078 alc = op->GetOpAttrListPtr();
00079
00080 for(; alc != NULL; alc = alc->GetNextListPtr())
00081 {
00082 a = alc->GetAttrPtr();
00083 if(!a) continue;
00084
00085 if(a->GetAttrType() == ATTR_LC)
00086 {
00087 for(a = alc->GetAttrPtr(); a != NULL;
00088 a = a->GetNextLcEntryPtr())
00089 {
00090 if(strncmp(a->GetAttrString(), "IA_jtbl:.section", 16) == 0)
00091 {
00092 directive = a->GetAttrString() + strlen("IA_jtbl:");
00093 fprintf(fp, "\t%s", directive);
00094 }
00095 if((strncmp(a->GetAttrString(), "IA_jtbl:", 8) == 0) &&
00096 strstr(a->GetAttrString(), "pcrel") != NULL)
00097 {
00098
00099 attrList *alist;
00100 for(alist = op->GetOpAttrListPtr(); alist != NULL;
00101 alist = alist->GetNextListPtr())
00102 {
00103 if(alist->GetAttrType() == ATTR_TBLNAME)
00104 {
00105 fprintf(fp, ".%s:\n",
00106 alist->GetTableName());
00107 }
00108 }
00109
00110 directive = a->GetAttrString() + strlen("IA_jtbl:");
00111 fprintf(fp, "%s", directive);
00112 }
00113 }
00114 }
00115
00116 }
00117 }
00118
00119
00120
00121 void WritePredicateOprd(legoOp *op)
00122 {
00123 legoOprd *pred;
00124
00125 for(pred = op->GetPredOprdPtr(); pred != NULL;
00126 pred = pred->GetNextOprdPtr())
00127 {
00128 if(pred->GetOprdType() == OT_REG)
00129 {
00130 fprintf(fp, "(p%d) ",
00131 pred->GetOprdRegNum());
00132 }
00133
00134 }
00135 }
00136
00137 void WriteBrOp(legoOp *op, legoProc * Proc)
00138 {
00139 branchQuals br;
00140 legoOprd *src, *dest;
00141
00142 br = Opcode->GetBranchQuals();
00143
00144 fprintf(fp, "br");
00145
00146 switch(br.type)
00147 {
00148 case BT_COND: fprintf(fp, ".cond");
00149 break;
00150 case BT_RET: fprintf(fp, ".ret");
00151 break;
00152 case BT_CALL: fprintf(fp,".call");
00153 break;
00154 case BT_NONE: break;
00155
00156 }
00157
00158 switch(br.predict)
00159 {
00160 case BH_SNT: fprintf(fp, ".spnt");
00161 break;
00162 case BH_ST: fprintf(fp, ".sptk");
00163 break;
00164 case BH_DNT: fprintf(fp, ".dpnt");
00165 break;
00166 case BH_DT: fprintf(fp, ".dptk");
00167 break;
00168 case BH_NONE: break;
00169 }
00170
00171 switch(br.prefetch)
00172 {
00173 case BPH_MANY: fprintf(fp, ".many");
00174 break;
00175 case BPH_FEW: fprintf(fp, ".few");
00176 break;
00177 case BPH_NONE: break;
00178 }
00179
00180 switch(br.dealloc)
00181 {
00182 case BDH_CLR: fprintf(fp, ".clr");
00183 break;
00184 case BDH_NONE: break;
00185 }
00186 fprintf(fp, " ");
00187 bool dest_exist = false;
00188 for(dest = op->GetDestOprdPtr(); dest != NULL;
00189 dest = dest->GetNextOprdPtr())
00190 {
00191 dest_exist = true;
00192 switch(dest->GetOprdType())
00193 {
00194 case OT_REG: fprintf(fp, " b%d",
00195 dest->GetOprdRegNum());
00196 break;
00197 case OT_LITERAL_S: fprintf(fp, " %s",
00198 dest->GetLiteralString());
00199 break;
00200 default: break;
00201
00202
00203
00204 }
00205 }
00206
00207
00208
00209 src = op->GetSrcOprdPtr();
00210 if(src != NULL)
00211 {
00212 if(dest_exist)
00213 fprintf(fp, " = ");
00214
00215 switch(src->GetOprdType())
00216 {
00217 case OT_REG: fprintf(fp, "b%d",
00218 src->GetOprdRegNum());
00219 break;
00220 case OT_LITERAL_S: fprintf(fp, "%s",
00221 src->GetLiteralString());
00222 break;
00223 case OT_LITERAL_CB:
00224
00225
00226
00227
00228
00229 fprintf(fp, ".C_%s_B%d", Proc->GetProcName(), src->GetLiteralControlBlock());
00230 break;
00231 default: LegoFatal("IA64Write",
00232 "Br have src oprd that is not a reg.or a literal string");
00233 exit(1);
00234 }
00235 }
00236
00237 fprintf(fp,"\n");
00238 }
00239
00240 void WriteCmpOprd(legoOp *op)
00241 {
00242 legoOprd *dest, *src;
00243 int counter;
00244
00245 for(dest = op->GetDestOprdPtr(), counter=0; dest != NULL;
00246 dest = dest->GetNextOprdPtr())
00247 {
00248 if(dest->GetOprdFileType() == FT_PR &&
00249 dest->GetOprdType() == OT_REG)
00250 {
00251 if(counter > 0)
00252 fprintf(fp, " p%d", dest->GetOprdRegNum());
00253 else
00254 {
00255 fprintf(fp, " p%d,",
00256 dest->GetOprdRegNum());
00257 counter++;
00258 }
00259 }
00260 else
00261 {
00262 LegoFatal("IA64Write",
00263 "Cmp have dest oprd that is not a predicate reg.");
00264 exit(1);
00265 }
00266 }
00267
00268 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
00269 src = src->GetNextOprdPtr())
00270 {
00271 switch(src->GetOprdType())
00272 {
00273 case OT_REG: switch(counter)
00274 {
00275 case 0: fprintf(fp, " = r%d,",
00276 src->GetOprdRegNum());
00277 counter++;
00278 break;
00279 case 1: fprintf(fp, " r%d",
00280 src->GetOprdRegNum());
00281 break;
00282 default: LegoFatal("IA64Write",
00283 "Cmp have a 3rd src oprd");
00284 exit(1);
00285 }
00286 break;
00287 case OT_LITERAL_S: switch(counter)
00288 {
00289 case 0: fprintf(fp, " = %s,",
00290 src->GetLiteralString());
00291 counter++;
00292 break;
00293 case 1: fprintf(fp, " %s",
00294 src->GetLiteralString());
00295 break;
00296 default: LegoFatal("IA64Write",
00297 "Cmp have a 3rd src oprd");
00298 exit(1);
00299 }
00300 break;
00301 case OT_LITERAL_LLNG: switch(counter)
00302 {
00303 case 0: fprintf(fp, " = %lld,",
00304 src->GetLiteralLongLong());
00305 counter++;
00306 break;
00307 case 1: fprintf(fp, " %lld",
00308 src->GetLiteralLongLong());
00309 break;
00310 default: LegoFatal("IA64Write",
00311 "Cmp have a 3rd src oprd");
00312 exit(1);
00313 }
00314 break;
00315 default: LegoFatal("IA64Write",
00316 "Cmp have src oprd that is not a reg. or a literal ");
00317 exit(1);
00318 }
00319 }
00320 }
00321
00322 void WriteCmpOp(legoOp *op)
00323 {
00324 icmpQuals icmp;
00325
00326 icmp = Opcode->GetIcmpQuals();
00327
00328 switch(op->GetOpcode())
00329 {
00330 case CMP: fprintf(fp, "cmp");
00331 break;
00332 case CMP_W: fprintf(fp, "cmp4");
00333 break;
00334 }
00335
00336 switch(icmp.relation)
00337 {
00338 case CR_EQ: fprintf(fp, ".eq");
00339 break;
00340 case CR_NE: fprintf(fp, ".ne");
00341 break;
00342 case CR_LT: fprintf(fp, ".lt");
00343 break;
00344 case CR_LE: fprintf(fp, ".le");
00345 break;
00346 case CR_GT: fprintf(fp, ".gt");
00347 break;
00348 case CR_GE: fprintf(fp, ".ge");
00349 break;
00350 case CR_LTU: fprintf(fp, ".ltu");
00351 break;
00352 case CR_LEU: fprintf(fp, ".leu");
00353 break;
00354 case CR_GTU: fprintf(fp, ".gtu");
00355 break;
00356 case CR_GEU: fprintf(fp, ".geu");
00357 break;
00358 }
00359
00360 switch(icmp.type)
00361 {
00362 case CT_UNC: fprintf(fp, ".unc");
00363 break;
00364 case CT_OR: fprintf(fp, ".or");
00365 break;
00366 case CT_AND: fprintf(fp, ".and");
00367 break;
00368 case CT_ORANDCM: fprintf(fp, ".or.andcm");
00369 break;
00370 case CT_ORCM: fprintf(fp, ".orcm");
00371 break;
00372 case CT_ANDCM: fprintf(fp, ".andcm");
00373 break;
00374 case CT_ANDORCM: fprintf(fp, ".and.orcm");
00375 break;
00376 case CT_NONE: break;
00377 }
00378
00379 WriteCmpOprd(op);
00380
00381 fprintf(fp, "\n");
00382 }
00383
00384 void WriteIaluOprd(legoOp *op)
00385 {
00386 legoOprd *src, *dest;
00387 int counter;
00388
00389 for(dest = op->GetDestOprdPtr(); dest != NULL;
00390 dest = dest->GetNextOprdPtr())
00391 {
00392 switch(dest->GetOprdType())
00393 {
00394 case OT_REG: fprintf(fp, " r%d",
00395 dest->GetOprdRegNum());
00396 break;
00397
00398 default: LegoFatal("IA64Write",
00399 "Ialu op have dest oprd that is not a reg.");
00400 exit(1);
00401 }
00402 }
00403 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
00404 src = src->GetNextOprdPtr())
00405 {
00406 switch(src->GetOprdType())
00407 {
00408
00409
00410 case OT_REG: switch(counter)
00411 {
00412 case 0: fprintf(fp, " = r%d",
00413 src->GetOprdRegNum());
00414 counter++;
00415 break;
00416 case 1: fprintf(fp, ", r%d",
00417 src->GetOprdRegNum());
00418 counter++;
00419 break;
00420 case 2: fprintf(fp, ", r%d",
00421 src->GetOprdRegNum());
00422 counter++;
00423 break;
00424 case 3: fprintf(fp, ", r%d",
00425 src->GetOprdRegNum());
00426 break;
00427 default: LegoFatal("IA64Write",
00428 "Ialu op have a unknown src oprd");
00429 exit(1);
00430 }
00431 break;
00432 case OT_LITERAL_S: switch(counter)
00433 {
00434 case 0: fprintf(fp, " = %s",
00435 src->GetLiteralString());
00436 counter++;
00437 break;
00438 case 1: fprintf(fp, ", %s",
00439 src->GetLiteralString());
00440 counter++;
00441 break;
00442 case 2: fprintf(fp, ", %s",
00443 src->GetLiteralString());
00444 counter++;
00445 break;
00446 case 3: fprintf(fp, ", %s",
00447 src->GetLiteralString());
00448 break;
00449 default: LegoFatal("IA64Write",
00450 "Ialu op have a unknown src oprd");
00451 exit(1);
00452 }
00453 break;
00454 case OT_LITERAL_LLNG: switch(counter)
00455 {
00456 case 0: fprintf(fp, " = %lld",
00457 src->GetLiteralLongLong());
00458 counter++;
00459 break;
00460 case 1: fprintf(fp, ", %lld",
00461 src->GetLiteralLongLong());
00462 counter++;
00463 break;
00464 case 2: fprintf(fp, ", %lld",
00465 src->GetLiteralLongLong());
00466 counter++;
00467 break;
00468 case 3: fprintf(fp, ", %lld",
00469 src->GetLiteralLongLong());
00470 break;
00471 default: LegoFatal("IA64Write",
00472 "Ialu op have a unknown src oprd");
00473 exit(1);
00474 }
00475 break;
00476
00477 default: LegoFatal("IA64Write",
00478 "Ialu op have src oprd that is not a reg. or a literal ");
00479 exit(1);
00480 }
00481 }
00482 }
00483
00484 void WriteMovOprd(legoOp *op)
00485 {
00486 legoOprd *dest, *src;
00487 int counter;
00488
00489 for(dest = op->GetDestOprdPtr(); dest != NULL;
00490 dest = dest->GetNextOprdPtr())
00491 {
00492 switch(dest->GetOprdType())
00493 {
00494 case OT_REG: switch(dest->GetOprdFileType())
00495 {
00496 case FT_GPR: fprintf(fp, " r%d",
00497 dest->GetOprdRegNum());
00498 break;
00499 case FT_FPR: fprintf(fp, " f%d",
00500 dest->GetOprdRegNum());
00501 break;
00502 case FT_CR: fprintf(fp, " ar%d",
00503 dest->GetOprdRegNum());
00504 break;
00505 case FT_PR: fprintf(fp, " p%d",
00506 dest->GetOprdRegNum());
00507 break;
00508 case FT_BTR: fprintf(fp, " b%d",
00509 dest->GetOprdRegNum());
00510 break;
00511 default: LegoFatal("IA64Write",
00512 "Mov have dest oprd that has a unknown reg file type.");
00513 exit(1);
00514
00515 }
00516 break;
00517 case OT_LITERAL_S: fprintf(fp, " %s",
00518 dest->GetLiteralString());
00519 break;
00520 default: LegoFatal("IA64Write",
00521 "Mov have dest oprd that is not a reg.");
00522 exit(1);
00523 }
00524 }
00525
00526
00527 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
00528 src = src->GetNextOprdPtr())
00529 {
00530 if(counter == 0)
00531 fprintf(fp, " = ");
00532 else
00533 fprintf(fp, ", ");
00534 switch(src->GetOprdType())
00535 {
00536 case OT_REG: switch(src->GetOprdFileType())
00537 {
00538 case FT_GPR: fprintf(fp, "r%d",
00539 src->GetOprdRegNum());
00540 break;
00541 case FT_FPR: fprintf(fp, "f%d",
00542 src->GetOprdRegNum());
00543 break;
00544 case FT_CR: fprintf(fp, "ar%d",
00545 src->GetOprdRegNum());
00546 break;
00547 case FT_PR: fprintf(fp, "p%d",
00548 src->GetOprdRegNum());
00549 break;
00550 case FT_BTR: fprintf(fp, "b%d",
00551 src->GetOprdRegNum());
00552 break;
00553 default: LegoFatal("IA64Write",
00554 "Mov have dest oprd that has a unknown reg file type.");
00555 exit(1);
00556
00557 }
00558 break;
00559 case OT_LITERAL_S: fprintf(fp, "%s",
00560 src->GetLiteralString());
00561 break;
00562 case OT_LITERAL_LLNG: fprintf(fp, "%lld",
00563 src->GetLiteralLongLong());
00564 break;
00565 default: LegoFatal("IA64Write",
00566 "Mov have src oprd that is not a reg. or literal");
00567 exit(1);
00568 }
00569 counter++;
00570 }
00571 }
00572
00573 void WriteXOprd(legoOp *op)
00574 {
00575 legoOprd *dest, *src;
00576 int counter;
00577
00578 for(dest = op->GetDestOprdPtr(); dest != NULL;
00579 dest = dest->GetNextOprdPtr())
00580 {
00581 switch(dest->GetOprdType())
00582 {
00583 case OT_REG: switch(dest->GetOprdFileType())
00584 {
00585 case FT_FPR: fprintf(fp, " f%d",
00586 dest->GetOprdRegNum());
00587 break;
00588 default: LegoFatal("IA64Write",
00589 "Xma or Xmpy have dest oprd that is not a Freg.");
00590 exit(1);
00591
00592 }
00593 break;
00594 default: LegoFatal("IA64Write",
00595 "Xma or XMPY have dest oprd that is not a reg.");
00596 exit(1);
00597 }
00598 }
00599
00600 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
00601 src = src->GetNextOprdPtr())
00602 {
00603 switch(src->GetOprdType())
00604 {
00605 case OT_REG: switch(src->GetOprdFileType())
00606 {
00607 case FT_FPR: switch(counter)
00608 {
00609 case 0: fprintf(fp, " = f%d,",
00610 src->GetOprdRegNum());
00611 counter++;
00612 break;
00613 case 1: fprintf(fp, " f%d",
00614 src->GetOprdRegNum());
00615 counter++;
00616 break;
00617 case 2: fprintf(fp, ", f%d",
00618 src->GetOprdRegNum());
00619 break;
00620 default: LegoFatal("IA64Write",
00621 "XMA or Xmpy op have a unknown src oprd");
00622 exit(1);
00623 }
00624 break;
00625 default: LegoFatal("IA64Write",
00626 "Xma or Xmpy have src oprd that is not a Freg.");
00627 exit(1);
00628
00629 }
00630 break;
00631 default: LegoFatal("IA64Write",
00632 "LD or ST op have src oprd that is not a reg. or a literal ");
00633 exit(1);
00634 }
00635 }
00636 }
00637
00638 void WriteIntOp(legoOp *op)
00639 {
00640 ialuQuals ialu;
00641
00642 ialu = Opcode->GetIaluQuals();
00643
00644 switch(op->GetOpcode())
00645 {
00646 case ADD: fprintf(fp, "add");
00647 WriteIaluOprd(op);
00648 break;
00649 case ADDS: fprintf(fp, "adds");
00650 WriteIaluOprd(op);
00651 break;
00652 case ADDL: fprintf(fp, "addl");
00653 WriteIaluOprd(op);
00654 break;
00655 case ADDP4: fprintf(fp, "addp4");
00656 WriteIaluOprd(op);
00657 break;
00658 case AND: fprintf(fp, "and");
00659 WriteIaluOprd(op);
00660 break;
00661 case ANDCM: fprintf(fp, "andcm");
00662 WriteIaluOprd(op);
00663 break;
00664 case CZX: fprintf(fp, "czx");
00665 switch(ialu.size)
00666 {
00667 case OS_B: fprintf(fp, "1");
00668 break;
00669 case OS_H: fprintf(fp, "2");
00670 break;
00671 }
00672
00673 switch(ialu.leftRight)
00674 {
00675 case OFLR_L: fprintf(fp, ".l");
00676 break;
00677 case OFLR_R: fprintf(fp, ".r");
00678 break;
00679 }
00680 WriteIaluOprd(op);
00681 break;
00682 case DEP: fprintf(fp, "dep");
00683 WriteIaluOprd(op);
00684 break;
00685 case DEPZ: fprintf(fp, "dep.z");
00686 WriteIaluOprd(op);
00687 break;
00688 case EXTR: fprintf(fp, "extr");
00689 switch(ialu.sign)
00690 {
00691 case OFS_UNSIGNED: fprintf(fp, ".u");
00692 break;
00693 case OFS_SIGNED: break;
00694 }
00695 WriteIaluOprd(op);
00696 break;
00697 case MIX: fprintf(fp, "mix");
00698 switch(ialu.size)
00699 {
00700 case OS_B: fprintf(fp, "1");
00701 break;
00702 case OS_H: fprintf(fp, "2");
00703 break;
00704 case OS_W: fprintf(fp, "4");
00705 break;
00706 }
00707 switch(ialu.leftRight)
00708 {
00709 case OFLR_L: fprintf(fp, ".l");
00710 break;
00711 case OFLR_R: fprintf(fp, ".r");
00712 break;
00713 }
00714 WriteIaluOprd(op);
00715 break;
00716 case MOV: fprintf(fp, "mov");
00717 switch(ialu.unit)
00718 {
00719 case OFMU_I: fprintf(fp, ".i");
00720 break;
00721 case OFMU_M: fprintf(fp, ".m");
00722 break;
00723 case OFMU_RET: fprintf(fp, ".ret");
00724 break;
00725 default: break;
00726 }
00727 WriteMovOprd(op);
00728 break;
00729 case MOVL: fprintf(fp, "movl");
00730 WriteMovOprd(op);
00731 break;
00732 case OR: fprintf(fp, "or");
00733 WriteIaluOprd(op);
00734 break;
00735 case POPCNT: fprintf(fp, "popcnt");
00736 WriteIaluOprd(op);
00737 break;
00738 case SHL: fprintf(fp, "shl");
00739 WriteIaluOprd(op);
00740 break;
00741 case SHLADD: fprintf(fp, "shladd");
00742 WriteIaluOprd(op);
00743 break;
00744 case SHLADDP4: fprintf(fp, "shladdp4");
00745 WriteIaluOprd(op);
00746 break;
00747 case SHR: fprintf(fp, "shr");
00748 if(ialu.sign == OFS_UNSIGNED)
00749 fprintf(fp, ".u");
00750 WriteIaluOprd(op);
00751 break;
00752 case SHRP: fprintf(fp, "shrp");
00753 WriteIaluOprd(op);
00754 break;
00755 case SUB: fprintf(fp, "sub");
00756 WriteIaluOprd(op);
00757 break;
00758 case SXT: fprintf(fp, "sxt");
00759 switch(ialu.size)
00760 {
00761 case OS_B: fprintf(fp, "1");
00762 break;
00763 case OS_H: fprintf(fp, "2");
00764 break;
00765 case OS_W: fprintf(fp, "4");
00766 break;
00767 }
00768 WriteIaluOprd(op);
00769 break;
00770 case TBIT: fprintf(fp, "tbit");
00771 switch(ialu.relation)
00772 {
00773 case TBR_NZ: fprintf(fp, ".nz");
00774 break;
00775 case TBR_Z: fprintf(fp, ".z");
00776 break;
00777 }
00778 switch(ialu.type)
00779 {
00780 case CT_UNC: fprintf(fp, ".unc");
00781 break;
00782 case CT_OR: fprintf(fp, ".or");
00783 break;
00784 case CT_AND: fprintf(fp, ".and");
00785 break;
00786 case CT_ORANDCM: fprintf(fp, ".or.andcm");
00787 break;
00788 case CT_ORCM: fprintf(fp, ".orcm");
00789 break;
00790 case CT_ANDCM: fprintf(fp, ".andcm");
00791 break;
00792 case CT_ANDORCM: fprintf(fp, ".and.orcm");
00793 break;
00794 case CT_NONE: break;
00795 }
00796 WriteCmpOprd(op);
00797 break;
00798 case TNAT: fprintf(fp, "tnat");
00799 switch(ialu.relation)
00800 {
00801 case TBR_NZ: fprintf(fp, ".nz");
00802 break;
00803 case TBR_Z: fprintf(fp, ".z");
00804 break;
00805 }
00806 switch(ialu.type)
00807 {
00808 case CT_UNC: fprintf(fp, ".unc");
00809 break;
00810 case CT_OR: fprintf(fp, ".or");
00811 break;
00812 case CT_AND: fprintf(fp, ".and");
00813 break;
00814 case CT_ORANDCM: fprintf(fp, ".or.andcm");
00815 break;
00816 case CT_ORCM: fprintf(fp, ".orcm");
00817 break;
00818 case CT_ANDCM: fprintf(fp, ".andcm");
00819 break;
00820 case CT_ANDORCM: fprintf(fp, ".and.orcm");
00821 break;
00822 case CT_NONE: break;
00823 }
00824 WriteCmpOprd(op);
00825 break;
00826 case XMA: fprintf(fp, "xma");
00827 switch(ialu.highLow)
00828 {
00829 case OFHL_HIGH: fprintf(fp,".h");
00830 break;
00831 case OFHL_LOW: fprintf(fp, ".l");
00832
00833 }
00834 if(ialu.sign == OFS_UNSIGNED)
00835 fprintf(fp, "u");
00836 WriteXOprd(op);
00837 break;
00838 case XMPY: fprintf(fp, "xmpy");
00839 switch(ialu.highLow)
00840 {
00841 case OFHL_HIGH: fprintf(fp,".h");
00842 break;
00843 case OFHL_LOW: fprintf(fp, ".l");
00844
00845 }
00846 if(ialu.sign == OFS_UNSIGNED)
00847 fprintf(fp, "u");
00848 WriteXOprd(op);
00849 break;
00850 case XOR: fprintf(fp, "xor");
00851 WriteIaluOprd(op);
00852 break;
00853 case ZXT: fprintf(fp, "zxt");
00854 switch(ialu.size)
00855 {
00856 case OS_B: fprintf(fp, "1");
00857 break;
00858 case OS_H: fprintf(fp, "2");
00859 break;
00860 case OS_W: fprintf(fp, "4");
00861 break;
00862 }
00863 WriteIaluOprd(op);
00864 break;
00865
00866 }
00867 fprintf(fp, "\n");
00868 }
00869 void WriteldstOprd(legoOp *op)
00870 {
00871 legoOprd *dest, *src;
00872 int counter;
00873
00874
00875
00876
00877
00878 counter = 0;
00879 dest = op->GetDestOprdPtr();
00880 if(dest != NULL)
00881 {
00882 switch(dest->GetOprdType())
00883 {
00884 case OT_REG: switch(dest->GetOprdFileType())
00885 {
00886 case FT_GPR: switch(op->GetOpcode())
00887 {
00888 case FETCHADD:
00889 case LD: fprintf(fp, " r%d",
00890 dest->GetOprdRegNum());
00891 break;
00892
00893
00894
00895
00896
00897 }
00898 break;
00899 default: LegoFatal("IA64Write",
00900 "Ld have dest oprd that is not a reg.");
00901 exit(1);
00902
00903 }
00904 break;
00905 default: LegoFatal("IA64Write",
00906 "LDST have dest oprd that is not a reg.");
00907 exit(1);
00908 }
00909 }
00910
00911 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
00912 src = src->GetNextOprdPtr())
00913 {
00914 switch(src->GetOprdType())
00915 {
00916 case OT_REG: switch(counter)
00917 {
00918 case 0: switch(op->GetOpcode())
00919 {
00920 case FETCHADD:
00921 case LD: fprintf(fp, " = [r%d]",
00922 src->GetOprdRegNum());
00923 counter++;
00924 break;
00925 case ST: fprintf(fp, " [r%d] = ",
00926 src->GetOprdRegNum());
00927 counter++;
00928 break;
00929 }
00930 break;
00931
00932 case 1: switch(op->GetOpcode())
00933 {
00934 case FETCHADD:
00935 case LD: fprintf(fp, ", r%d", src->GetOprdRegNum());
00936 break;
00937 case ST: fprintf(fp, "r%d", src->GetOprdRegNum());
00938 break;
00939 }
00940 counter++;
00941 break;
00942 default: LegoFatal("IA64Write",
00943 "LdSt op have a unknown src oprd");
00944 exit(1);
00945 }
00946 break;
00947 case OT_LITERAL_S: fprintf(fp, ", %s",
00948 src->GetLiteralString());
00949 break;
00950 case OT_LITERAL_LLNG: fprintf(fp, ", %lld",
00951 src->GetLiteralLongLong());
00952 break;
00953 default: LegoFatal("IA64Write",
00954 "LDST op have src oprd that is not a reg. or a literal ");
00955 exit(1);
00956 }
00957 }
00958 }
00959
00960 void WriteLfetchOprd(legoOp *op)
00961 {
00962 legoOprd *src;
00963 int counter;
00964
00965 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
00966 src = src->GetNextOprdPtr())
00967 {
00968 switch(src->GetOprdType())
00969 {
00970 case OT_REG: switch(src->GetOprdFileType())
00971 {
00972 case FT_GPR: switch(counter)
00973 {
00974 case 1: fprintf(fp, ", r%d",
00975 src->GetOprdRegNum());
00976 break;
00977 case 0: fprintf(fp, " [r%d]",
00978 src->GetOprdRegNum());
00979 counter++;
00980 break;
00981 }
00982 break;
00983 default: LegoFatal("IA64Write",
00984 "Lfetch have a src oprd that is not a Greg.");
00985 exit(1);
00986
00987 }
00988 break;
00989 case OT_LITERAL_S: fprintf(fp, ", %s",
00990 src->GetLiteralString());
00991 break;
00992 case OT_LITERAL_LLNG: fprintf(fp, ", %lld",
00993 src->GetLiteralLongLong());
00994 break;
00995 default: LegoFatal("IA64Write",
00996 "Lfetch have a src oprd that is not a reg.");
00997 exit(1);
00998 }
00999 }
01000 }
01001 void WriteIldstOp(legoOp *op)
01002 {
01003 ildstQuals ildst;
01004
01005 ildst = Opcode->GetImemQuals();
01006
01007 switch(op->GetOpcode())
01008 {
01009 case FETCHADD: fprintf(fp, "fetchadd");
01010 switch(ildst.size)
01011 {
01012 case OS_W: fprintf(fp, "4");
01013 break;
01014 case OS_X: fprintf(fp, "8");
01015 break;
01016 }
01017 switch(ildst.sem)
01018 {
01019 case FAS_ACQ: fprintf(fp, ".acq");
01020 break;
01021 case FAS_REL: fprintf(fp, ".rel");
01022 }
01023 switch(ildst.hint)
01024 {
01025 case LSH_NT1: fprintf(fp, ".nt1");
01026 break;
01027 case LSH_NTA: fprintf(fp, ".nta");
01028 break;
01029 case LSH_NONE: break;
01030
01031 }
01032 WriteldstOprd(op);
01033 break;
01034 case LD: fprintf(fp, "ld");
01035 switch(ildst.size)
01036 {
01037 case OS_B: fprintf(fp, "1");
01038 break;
01039 case OS_H: fprintf(fp, "2");
01040 break;
01041 case OS_W: fprintf(fp, "4");
01042 break;
01043 case OS_X: fprintf(fp, "8");
01044 break;
01045 }
01046 switch(ildst.type)
01047 {
01048 case LST_S: fprintf(fp, ".s");
01049 break;
01050 case LST_A: fprintf(fp, ".a");
01051 break;
01052 case LST_SA: fprintf(fp, ".sa");
01053 break;
01054 case LST_CNC: fprintf(fp, ".c.nc");
01055 break;
01056 case LST_CC: fprintf(fp, ".c.clr");
01057 break;
01058 case LST_CCACQ: fprintf(fp, ".c.clr.acq");
01059 break;
01060 case LST_ACQ: fprintf(fp, ".acq");
01061 break;
01062 case LST_BIAS: fprintf(fp, ".bias");
01063 break;
01064 case LST_FILL: fprintf(fp, ".fill");
01065 break;
01066 }
01067 switch(ildst.hint)
01068 {
01069 case LSH_NT1: fprintf(fp, ".nt1");
01070 break;
01071 case LSH_NTA: fprintf(fp, ".nta");
01072 break;
01073 case LSH_NONE: break;
01074 }
01075 WriteldstOprd(op);
01076 break;
01077 case LFETCH: fprintf(fp, "lfetch");
01078 switch(ildst.type)
01079 {
01080 case LST_NONEEXC: fprintf(fp, ".excl");
01081 break;
01082 case LST_FAULT: fprintf(fp, ".fault");
01083 break;
01084 case LST_FAULTEXC: fprintf(fp, ".fault.excl");
01085 break;
01086 case LST_NONE: break;
01087 }
01088 switch(ildst.hint)
01089 {
01090 case LSH_NT1: fprintf(fp, ".nt1");
01091 break;
01092 case LSH_NT2: fprintf(fp, ".nt2");
01093 break;
01094 case LSH_NTA: fprintf(fp, ".nta");
01095 break;
01096 case LSH_NONE: break;
01097 }
01098 WriteLfetchOprd(op);
01099 break;
01100 case ST: fprintf(fp, "st");
01101 switch(ildst.size)
01102 {
01103 case OS_B: fprintf(fp, "1");
01104 break;
01105 case OS_H: fprintf(fp, "2");
01106 break;
01107 case OS_W: fprintf(fp, "4");
01108 break;
01109 case OS_X: fprintf(fp, "8");
01110 break;
01111 }
01112 switch(ildst.type)
01113 {
01114 case LST_REL: fprintf(fp, ".rel");
01115 break;
01116 case LST_SPILL: fprintf(fp, ".spill");
01117 break;
01118 case LST_NONE: break;
01119 }
01120 switch(ildst.hint)
01121 {
01122 case LSH_NTA: fprintf(fp, ".nta");
01123 break;
01124 case LSH_NONE: break;
01125 }
01126 WriteldstOprd(op);
01127 break;
01128 case XCHG: fprintf(fp, "xchg");
01129 switch(ildst.size)
01130 {
01131 case OS_B: fprintf(fp, "1");
01132 break;
01133 case OS_H: fprintf(fp, "2");
01134 break;
01135 case OS_W: fprintf(fp, "4");
01136 break;
01137 case OS_X: fprintf(fp, "8");
01138 break;
01139 }
01140 switch(ildst.hint)
01141 {
01142 case LSH_NT1: fprintf(fp, ".nt1");
01143 break;
01144 case LSH_NTA: fprintf(fp, ".nta");
01145 break;
01146 case LSH_NONE: break;
01147 }
01148 break;
01149 case CMPXCHG: fprintf(fp, "cmpxchg");
01150 switch(ildst.size)
01151 {
01152 case OS_B: fprintf(fp, "1");
01153 break;
01154 case OS_H: fprintf(fp, "2");
01155 break;
01156 case OS_W: fprintf(fp, "4");
01157 break;
01158 case OS_X: fprintf(fp, "8");
01159 break;
01160 }
01161 switch(ildst.sem)
01162 {
01163 case FAS_ACQ: fprintf(fp, ".acq");
01164 break;
01165 case FAS_REL: fprintf(fp, ".rel");
01166 }
01167 switch(ildst.hint)
01168 {
01169 case LSH_NT1: fprintf(fp, ".nt1");
01170 break;
01171 case LSH_NTA: fprintf(fp, ".nta");
01172 break;
01173 case LSH_NONE: break;
01174
01175 }
01176 break;
01177 }
01178 fprintf(fp, "\n");
01179 }
01180
01181 void WriteGSetfOprd(legoOp *op)
01182 {
01183 legoOprd *dest, *src;
01184 int counter;
01185
01186 for(dest = op->GetDestOprdPtr(); dest != NULL;
01187 dest = dest->GetNextOprdPtr())
01188 {
01189 switch(dest->GetOprdType())
01190 {
01191 case OT_REG: switch(dest->GetOprdFileType())
01192 {
01193 case FT_GPR: fprintf(fp, " r%d",
01194 dest->GetOprdRegNum());
01195 break;
01196 case FT_FPR: fprintf(fp, " f%d",
01197 dest->GetOprdRegNum());
01198 break;
01199 default: LegoFatal("IA64Write",
01200 "Getf or SetF have dest oprd that is not a greg or freg.");
01201 exit(1);
01202
01203 }
01204 break;
01205 default: LegoFatal("IA64Write",
01206 "Getf or Setf have dest oprd that is not a reg.");
01207 exit(1);
01208 }
01209 }
01210
01211 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
01212 src = src->GetNextOprdPtr())
01213 {
01214 switch(src->GetOprdType())
01215 {
01216 case OT_REG: switch(src->GetOprdFileType())
01217 {
01218 case FT_FPR: fprintf(fp, " = f%d",
01219 src->GetOprdRegNum());
01220 break;
01221 case FT_GPR: fprintf(fp, " = r%d",
01222 src->GetOprdRegNum());
01223 break;
01224 default: LegoFatal("IA64Write",
01225 "Getf or Setf have src oprd that is not a Freg or greg.");
01226 exit(1);
01227
01228 }
01229 break;
01230 default: LegoFatal("IA64Write",
01231 "Getf or Setf op have src oprd that is not a reg.");
01232 exit(1);
01233 }
01234 }
01235 }
01236
01237 void WriteFpOprd(legoOp *op)
01238 {
01239 legoOprd *dest, *src;
01240 int counter;
01241
01242 for(dest = op->GetDestOprdPtr(); dest != NULL;
01243 dest = dest->GetNextOprdPtr())
01244 {
01245 switch(dest->GetOprdType())
01246 {
01247 case OT_REG: switch(dest->GetOprdFileType())
01248 {
01249 case FT_FPR: fprintf(fp, " f%d",
01250 dest->GetOprdRegNum());
01251 break;
01252 default: LegoFatal("IA64Write",
01253 "FP op have dest oprd that is not a Freg.");
01254 exit(1);
01255
01256 }
01257 break;
01258 default: LegoFatal("IA64Write",
01259 "FP op have dest oprd that is not a reg.");
01260 exit(1);
01261 }
01262 }
01263
01264 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
01265 src = src->GetNextOprdPtr())
01266 {
01267 switch(src->GetOprdType())
01268 {
01269 case OT_REG: switch(src->GetOprdFileType())
01270 {
01271 case FT_FPR: switch(counter)
01272 {
01273 case 0: fprintf(fp, " = f%d",
01274 src->GetOprdRegNum());
01275 counter++;
01276 break;
01277 case 1: fprintf(fp, ", f%d",
01278 src->GetOprdRegNum());
01279 counter++;
01280 break;
01281 case 2: fprintf(fp, ", f%d",
01282 src->GetOprdRegNum());
01283 break;
01284 default: LegoFatal("IA64Write",
01285 "XMA or Xmpy op have a unknown src oprd");
01286 exit(1);
01287 }
01288 break;
01289 default: LegoFatal("IA64Write",
01290 "FP op have src oprd that is not a Freg.");
01291 exit(1);
01292
01293 }
01294 break;
01295 default: LegoFatal("IA64Write",
01296 "FP op have src oprd that is not a reg.");
01297 exit(1);
01298 }
01299 }
01300 }
01301
01302 void WriteFCmpOprd(legoOp *op)
01303 {
01304 legoOprd *dest, *src;
01305 int counter;
01306
01307 for(dest = op->GetDestOprdPtr(), counter=0; dest != NULL;
01308 dest = dest->GetNextOprdPtr())
01309 {
01310 switch(dest->GetOprdType())
01311 {
01312 case OT_REG: switch(dest->GetOprdFileType())
01313 {
01314 case FT_PR: switch(counter)
01315 {
01316 case 0: fprintf(fp, " p%d",
01317 dest->GetOprdRegNum());
01318 counter++;
01319 break;
01320 default: fprintf(fp, ", p%d",
01321 dest->GetOprdRegNum());
01322 counter++;
01323 break;
01324 }
01325 break;
01326 case FT_FPR: switch(counter)
01327 {
01328 case 0: fprintf(fp, " f%d",
01329 dest->GetOprdRegNum());
01330 counter++;
01331 break;
01332 default: fprintf(fp, ", f%d",
01333 dest->GetOprdRegNum());
01334 counter++;
01335 break;
01336 }
01337 break;
01338 default: LegoFatal("IA64Write",
01339 "Fcmp have dest oprd that is not a preg or freg.");
01340 exit(1);
01341
01342 }
01343 break;
01344 default: LegoFatal("IA64Write",
01345 "FP op have dest oprd that is not a reg.");
01346 exit(1);
01347 }
01348 }
01349
01350 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
01351 src = src->GetNextOprdPtr())
01352 {
01353 switch(src->GetOprdType())
01354 {
01355 case OT_REG: switch(counter)
01356 {
01357 case 0: fprintf(fp, " = f%d",
01358 src->GetOprdRegNum());
01359 counter++;
01360 break;
01361 case 1: fprintf(fp, ", f%d",
01362 src->GetOprdRegNum());
01363 break;
01364 default: LegoFatal("IA64Write",
01365 "FCmp have a 3rd src oprd");
01366 exit(1);
01367 }
01368 break;
01369 case OT_LITERAL_S: switch(counter)
01370 {
01371 case 0: fprintf(fp, " = %s",
01372 src->GetLiteralString());
01373 counter++;
01374 break;
01375 case 1: fprintf(fp, ", %s",
01376 src->GetLiteralString());
01377 break;
01378 default: LegoFatal("IA64Write",
01379 "FCmp have a 3rd src oprd");
01380 exit(1);
01381 }
01382 break;
01383 case OT_LITERAL_LLNG: switch(counter)
01384 {
01385 case 0: fprintf(fp, " = %lld",
01386 src->GetLiteralLongLong());
01387 counter++;
01388 break;
01389 case 1: fprintf(fp, ", %lld",
01390 src->GetLiteralLongLong());
01391 break;
01392 default: LegoFatal("IA64Write",
01393 "FCmp have a 3rd src oprd");
01394 exit(1);
01395 }
01396 break;
01397 default: LegoFatal("IA64Write",
01398 "FCmp have src oprd that is not a reg. or a literal ");
01399 exit(1);
01400 }
01401 }
01402 }
01403
01404 void WriteFpOp(legoOp *op)
01405 {
01406 faluQuals falu;
01407
01408 falu = Opcode->GetFaluQuals();
01409
01410 switch(op->GetOpcode())
01411 {
01412 case FABS: fprintf(fp, "fabs");
01413 WriteFpOprd(op);
01414 break;
01415 case FADD: fprintf(fp, "fadd");
01416 switch(falu.precision)
01417 {
01418 case FPP_S: fprintf(fp, ".s");
01419 break;
01420 case FPP_D: fprintf(fp, ".d");
01421 break;
01422 case FPP_NONE: break;
01423 }
01424 switch(falu.sfield)
01425 {
01426 case FPSF_F0: fprintf(fp, ".s0");
01427 break;
01428 case FPSF_F1: fprintf(fp, ".s1");
01429 break;
01430 case FPSF_F2: fprintf(fp, ".s2");
01431 break;
01432 case FPSF_F3: fprintf(fp, ".s3");
01433 break;
01434 case FPSF_NONE: break;
01435 }
01436 WriteFpOprd(op);
01437 break;
01438 case FAMAX: fprintf(fp, "famax");
01439 switch(falu.sfield)
01440 {
01441 case FPSF_F0: fprintf(fp, ".s0");
01442 break;
01443 case FPSF_F1: fprintf(fp, ".s1");
01444 break;
01445 case FPSF_F2: fprintf(fp, ".s2");
01446 break;
01447 case FPSF_F3: fprintf(fp, ".s3");
01448 break;
01449 case FPSF_NONE: break;
01450 }
01451 WriteFpOprd(op);
01452 break;
01453 case FAMIN: fprintf(fp, "famin");
01454 switch(falu.sfield)
01455 {
01456 case FPSF_F0: fprintf(fp, ".s0");
01457 break;
01458 case FPSF_F1: fprintf(fp, ".s1");
01459 break;
01460 case FPSF_F2: fprintf(fp, ".s2");
01461 break;
01462 case FPSF_F3: fprintf(fp, ".s3");
01463 break;
01464 case FPSF_NONE: break;
01465 }
01466 WriteFpOprd(op);
01467 break;
01468 case FAND: fprintf(fp, "fand");
01469 WriteFpOprd(op);
01470 break;
01471 case FANDCM: fprintf(fp, "fandcm");
01472 WriteFpOprd(op);
01473 break;
01474 case FCVT: fprintf(fp, "fcvt");
01475 switch(falu.ctype)
01476 {
01477 case OFCV_FX: fprintf(fp, ".fx");
01478 break;
01479 case OFCV_FXU: fprintf(fp, ".fxu");
01480 break;
01481 case OFCV_XUF: fprintf(fp, ".xuf");
01482 break;
01483 case OFCV_XF: fprintf(fp, ".xf");
01484 break;
01485 }
01486 switch(falu.trunc)
01487 {
01488 case OFT_TRUNC: fprintf(fp, ".trunc");
01489 break;
01490 case OFT_NOTRUNC: break;
01491 }
01492 switch(falu.sfield)
01493 {
01494 case FPSF_F0: fprintf(fp, ".s0");
01495 break;
01496 case FPSF_F1: fprintf(fp, ".s1");
01497 break;
01498 case FPSF_F2: fprintf(fp, ".s2");
01499 break;
01500 case FPSF_F3: fprintf(fp, ".s3");
01501 break;
01502 case FPSF_NONE: break;
01503 }
01504 WriteFpOprd(op);
01505 break;
01506 case FMA: fprintf(fp, "fma");
01507 switch(falu.precision)
01508 {
01509 case FPP_S: fprintf(fp, ".s");
01510 break;
01511 case FPP_D: fprintf(fp, ".d");
01512 break;
01513 case FPP_NONE: break;
01514 }
01515 switch(falu.sfield)
01516 {
01517 case FPSF_F0: fprintf(fp, ".s0");
01518 break;
01519 case FPSF_F1: fprintf(fp, ".s1");
01520 break;
01521 case FPSF_F2: fprintf(fp, ".s2");
01522 break;
01523 case FPSF_F3: fprintf(fp, ".s3");
01524 break;
01525 case FPSF_NONE: break;
01526 }
01527 WriteFpOprd(op);
01528 break;
01529 case FMAX: fprintf(fp, "fmax");
01530 switch(falu.sfield)
01531 {
01532 case FPSF_F0: fprintf(fp, ".s0");
01533 break;
01534 case FPSF_F1: fprintf(fp, ".s1");
01535 break;
01536 case FPSF_F2: fprintf(fp, ".s2");
01537 break;
01538 case FPSF_F3: fprintf(fp, ".s3");
01539 break;
01540 case FPSF_NONE: break;
01541 }
01542 WriteFpOprd(op);
01543 break;
01544 case FMERGE: fprintf(fp, "fmerge");
01545 switch(falu.mergeForm)
01546 {
01547 case OFFM_NEGSIGN: fprintf(fp, ".ns");
01548 break;
01549 case OFFM_SIGN: fprintf(fp, ".s");
01550 break;
01551 case OFFM_EXP: fprintf(fp, ".se");
01552 break;
01553 }
01554 WriteFpOprd(op);
01555 break;
01556 case FMIN: fprintf(fp, "fmin");
01557 switch(falu.sfield)
01558 {
01559 case FPSF_F0: fprintf(fp, ".s0");
01560 break;
01561 case FPSF_F1: fprintf(fp, ".s1");
01562 break;
01563 case FPSF_F2: fprintf(fp, ".s2");
01564 break;
01565 case FPSF_F3: fprintf(fp, ".s3");
01566 break;
01567 case FPSF_NONE: break;
01568 }
01569 WriteFpOprd(op);
01570 break;
01571 case FMIX: fprintf(fp, "fmix");
01572 switch(falu.leftRight)
01573 {
01574 case OFLR_L: fprintf(fp, ".l");
01575 break;
01576 case OFLR_R: fprintf(fp, ".r");
01577 break;
01578 case OFLR_LR: fprintf(fp, ".lr");
01579 break;
01580 }
01581 WriteFpOprd(op);
01582 break;
01583 case FMPY: fprintf(fp, "fmpy");
01584 switch(falu.precision)
01585 {
01586 case FPP_S: fprintf(fp, ".s");
01587 break;
01588 case FPP_D: fprintf(fp, ".d");
01589 break;
01590 case FPP_NONE: break;
01591 }
01592 switch(falu.sfield)
01593 {
01594 case FPSF_F0: fprintf(fp, ".s0");
01595 break;
01596 case FPSF_F1: fprintf(fp, ".s1");
01597 break;
01598 case FPSF_F2: fprintf(fp, ".s2");
01599 break;
01600 case FPSF_F3: fprintf(fp, ".s3");
01601 break;
01602 case FPSF_NONE: break;
01603 }
01604 WriteFpOprd(op);
01605 break;
01606 case FMS: fprintf(fp, "fms");
01607 switch(falu.precision)
01608 {
01609 case FPP_S: fprintf(fp, ".s");
01610 break;
01611 case FPP_D: fprintf(fp, ".d");
01612 break;
01613 case FPP_NONE: break;
01614 }
01615 switch(falu.sfield)
01616 {
01617 case FPSF_F0: fprintf(fp, ".s0");
01618 break;
01619 case FPSF_F1: fprintf(fp, ".s1");
01620 break;
01621 case FPSF_F2: fprintf(fp, ".s2");
01622 break;
01623 case FPSF_F3: fprintf(fp, ".s3");
01624 break;
01625 case FPSF_NONE: break;
01626 }
01627 WriteFpOprd(op);
01628 break;
01629 case FNEG: fprintf(fp, "fneg");
01630 WriteFpOprd(op);
01631 break;
01632 case FNEGABS: fprintf(fp, "fnegabs");
01633 WriteFpOprd(op);
01634 break;
01635 case FNMA: fprintf(fp, "fnma");
01636 switch(falu.precision)
01637 {
01638 case FPP_S: fprintf(fp, ".s");
01639 break;
01640 case FPP_D: fprintf(fp, ".d");
01641 break;
01642 case FPP_NONE: break;
01643 }
01644 switch(falu.sfield)
01645 {
01646 case FPSF_F0: fprintf(fp, ".s0");
01647 break;
01648 case FPSF_F1: fprintf(fp, ".s1");
01649 break;
01650 case FPSF_F2: fprintf(fp, ".s2");
01651 break;
01652 case FPSF_F3: fprintf(fp, ".s3");
01653 break;
01654 case FPSF_NONE: break;
01655 }
01656 WriteFpOprd(op);
01657 break;
01658 case FNMPY: fprintf(fp, "fnmpy");
01659 switch(falu.precision)
01660 {
01661 case FPP_S: fprintf(fp, ".s");
01662 break;
01663 case FPP_D: fprintf(fp, ".d");
01664 break;
01665 case FPP_NONE: break;
01666 }
01667 switch(falu.sfield)
01668 {
01669 case FPSF_F0: fprintf(fp, ".s0");
01670 break;
01671 case FPSF_F1: fprintf(fp, ".s1");
01672 break;
01673 case FPSF_F2: fprintf(fp, ".s2");
01674 break;
01675 case FPSF_F3: fprintf(fp, ".s3");
01676 break;
01677 case FPSF_NONE: break;
01678 }
01679 WriteFpOprd(op);
01680 break;
01681 case FNORM: fprintf(fp, "fnorm");
01682 switch(falu.precision)
01683 {
01684 case FPP_S: fprintf(fp, ".s");
01685 break;
01686 case FPP_D: fprintf(fp, ".d");
01687 break;
01688 case FPP_NONE: break;
01689 }
01690 switch(falu.sfield)
01691 {
01692 case FPSF_F0: fprintf(fp, ".s0");
01693 break;
01694 case FPSF_F1: fprintf(fp, ".s1");
01695 break;
01696 case FPSF_F2: fprintf(fp, ".s2");
01697 break;
01698 case FPSF_F3: fprintf(fp, ".s3");
01699 break;
01700 case FPSF_NONE: break;
01701 }
01702 WriteFpOprd(op);
01703 break;
01704 case FOR: fprintf(fp, "for");
01705 WriteFpOprd(op);
01706 break;
01707 case FRCPA: fprintf(fp, "frcpa");
01708 switch(falu.sfield)
01709 {
01710 case FPSF_F0: fprintf(fp, ".s0");
01711 break;
01712 case FPSF_F1: fprintf(fp, ".s1");
01713 break;
01714 case FPSF_F2: fprintf(fp, ".s2");
01715 break;
01716 case FPSF_F3: fprintf(fp, ".s3");
01717 break;
01718 case FPSF_NONE: break;
01719 }
01720 WriteFCmpOprd(op);
01721 break;
01722 case FRSQRTA: fprintf(fp, "frsqrta");
01723 switch(falu.sfield)
01724 {
01725 case FPSF_F0: fprintf(fp, ".s0");
01726 break;
01727 case FPSF_F1: fprintf(fp, ".s1");
01728 break;
01729 case FPSF_F2: fprintf(fp, ".s2");
01730 break;
01731 case FPSF_F3: fprintf(fp, ".s3");
01732 break;
01733 case FPSF_NONE: break;
01734 }
01735 WriteFCmpOprd(op);
01736 break;
01737 case FSELECT: fprintf(fp, "fselect");
01738 WriteFpOprd(op);
01739 break;
01740 case FSUB: fprintf(fp, "fsub");
01741 switch(falu.precision)
01742 {
01743 case FPP_S: fprintf(fp, ".s");
01744 break;
01745 case FPP_D: fprintf(fp, ".d");
01746 break;
01747 case FPP_NONE: break;
01748 }
01749 switch(falu.sfield)
01750 {
01751 case FPSF_F0: fprintf(fp, ".s0");
01752 break;
01753 case FPSF_F1: fprintf(fp, ".s1");
01754 break;
01755 case FPSF_F2: fprintf(fp, ".s2");
01756 break;
01757 case FPSF_F3: fprintf(fp, ".s3");
01758 break;
01759 case FPSF_NONE: break;
01760 }
01761 WriteFpOprd(op);
01762 break;
01763 case FSWAP: fprintf(fp, "fswap");
01764 switch(falu.leftRight)
01765 {
01766 case OFLR_L: fprintf(fp, ".l");
01767 break;
01768 case OFLR_R: fprintf(fp, ".r");
01769 break;
01770 case OFLR_NONE: break;
01771 }
01772 WriteFpOprd(op);
01773 break;
01774 case FXOR: fprintf(fp, "fxor");
01775 WriteFpOprd(op);
01776 break;
01777 case GETF: fprintf(fp, "getf");
01778 switch(falu.getSetForm)
01779 {
01780 case OFFC_S: fprintf(fp,".s");
01781 break;
01782 case OFFC_D: fprintf(fp,".d");
01783 break;
01784 case OFFC_EXP: fprintf(fp,".exp");
01785 break;
01786 case OFFC_SIG: fprintf(fp,".sig");
01787 break;
01788 }
01789 WriteGSetfOprd(op);
01790 break;
01791 case SETF: fprintf(fp, "setf");
01792 switch(falu.getSetForm)
01793 {
01794 case OFFC_S: fprintf(fp,".s");
01795 break;
01796 case OFFC_D: fprintf(fp,".d");
01797 break;
01798 case OFFC_EXP: fprintf(fp,".exp");
01799 break;
01800 case OFFC_SIG: fprintf(fp,".sig");
01801 break;
01802 }
01803 WriteGSetfOprd(op);
01804 break;
01805 case FSXT: fprintf(fp, "fsxt");
01806 switch(falu.leftRight)
01807 {
01808 case OFLR_L: fprintf(fp, ".l");
01809 break;
01810 case OFLR_R: fprintf(fp, ".r");
01811 break;
01812 }
01813 WriteFpOprd(op);
01814 break;
01815 }
01816 fprintf(fp, "\n");
01817 }
01818
01819 void WriteLDFOprd(legoOp *op)
01820 {
01821 legoOprd *dest, *src;
01822 int counter;
01823
01824
01825
01826
01827 for(dest = op->GetDestOprdPtr(), counter = 0; dest != NULL;
01828 dest = dest->GetNextOprdPtr())
01829 {
01830 switch(dest->GetOprdType())
01831 {
01832 case OT_REG: switch(op->GetOpcode())
01833 {
01834 case LDFP:
01835 switch(counter)
01836 {
01837 case 0: fprintf(fp, " f%d",
01838 dest->GetOprdRegNum());
01839 counter++;
01840 break;
01841 default: fprintf(fp, ", f%d",
01842 dest->GetOprdRegNum());
01843 counter++;
01844 assert(counter <= 2);
01845 break;
01846 }
01847 break;
01848 case LDF:
01849 if(counter == 0)
01850 {
01851 fprintf(fp, " f%d",dest->GetOprdRegNum());
01852
01853 }
01854 counter++;
01855 break;
01856 }
01857 break;
01858 default: LegoFatal("IA64Write",
01859 "LDST of FP have dest oprd that is not a reg.");
01860 exit(1);
01861 }
01862 }
01863
01864 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
01865 src = src->GetNextOprdPtr())
01866 {
01867 switch(src->GetOprdType())
01868 {
01869 case OT_REG: switch(counter)
01870 {
01871 case 0: switch(op->GetOpcode())
01872 {
01873 case LDFP:
01874 case LDF: fprintf(fp, " = [r%d]",
01875 src->GetOprdRegNum());
01876 counter++;
01877 break;
01878 case STF: fprintf(fp, " [r%d] = ",
01879 src->GetOprdRegNum());
01880 counter++;
01881 break;
01882 }
01883 break;
01884 case 1: if(op->GetOpcode() == STF)
01885 {
01886 fprintf(fp, "f%d", src->GetOprdRegNum());
01887 }
01888 else
01889 {
01890 fprintf(fp, ", r%d", src->GetOprdRegNum());
01891 }
01892 counter++;
01893 break;
01894 default: LegoFatal("IA64Write",
01895 "LdSt op have a unknown src oprd");
01896 exit(1);
01897 }
01898 break;
01899 case OT_LITERAL_S: fprintf(fp, ", %s",
01900 src->GetLiteralString());
01901 break;
01902 case OT_LITERAL_LLNG: fprintf(fp, ", %lld",
01903 src->GetLiteralLongLong());
01904 break;
01905 default: LegoFatal("IA64Write",
01906 "LDST of FP op have src oprd that is not a reg. or a literal ");
01907 exit(1);
01908 }
01909 }
01910 }
01911
01912 void WriteFpLdstOp(legoOp *op)
01913 {
01914 fldstQuals fldst;
01915
01916 fldst = Opcode->GetFmemQuals();
01917
01918 switch(op->GetOpcode())
01919 {
01920 case LDF: fprintf(fp, "ldf");
01921 switch(fldst.size)
01922 {
01923 case FLSS_S: fprintf(fp, "s");
01924 break;
01925 case FLSS_D: fprintf(fp, "d");
01926 break;
01927 case FLSS_E: fprintf(fp, "e");
01928 break;
01929 case FLSS_I: fprintf(fp, "8");
01930 break;
01931 case FLSS_NONE: break;
01932 }
01933 switch(fldst.type)
01934 {
01935 case LST_S: fprintf(fp, ".s");
01936 break;
01937 case LST_A: fprintf(fp, ".a");
01938 break;
01939 case LST_SA: fprintf(fp, ".sa");
01940 break;
01941 case LST_CNC: fprintf(fp, ".c.nc");
01942 break;
01943 case LST_CC: fprintf(fp, ".c.clr");
01944 break;
01945 case LST_FILL: fprintf(fp, ".fill");
01946 break;
01947 case LST_NONE: break;
01948 }
01949 switch(fldst.hint)
01950 {
01951 case LSH_NT1: fprintf(fp, ".nt1");
01952 break;
01953 case LSH_NTA: fprintf(fp, ".nta");
01954 break;
01955 case LSH_NONE: break;
01956 }
01957 WriteLDFOprd(op);
01958 break;
01959 case LDFP: fprintf(fp, "ldfp");
01960 switch(fldst.size)
01961 {
01962 case FLSS_S: fprintf(fp, "s");
01963 break;
01964 case FLSS_D: fprintf(fp, "d");
01965 break;
01966 case FLSS_I: fprintf(fp, "8");
01967 break;
01968 }
01969 switch(fldst.type)
01970 {
01971 case LST_S: fprintf(fp, ".s");
01972 break;
01973 case LST_A: fprintf(fp, ".a");
01974 break;
01975 case LST_SA: fprintf(fp, ".sa");
01976 break;
01977 case LST_CNC: fprintf(fp, ".c.nc");
01978 break;
01979 case LST_CC: fprintf(fp, ".c.clr");
01980 break;
01981 case LST_FILL: fprintf(fp, ".fill");
01982 break;
01983 case LST_NONE: break;
01984 }
01985 switch(fldst.hint)
01986 {
01987 case LSH_NT1: fprintf(fp, ".nt1");
01988 break;
01989 case LSH_NTA: fprintf(fp, ".nta");
01990 break;
01991 case LSH_NONE: break;
01992 }
01993 WriteLDFOprd(op);
01994 break;
01995 case STF: fprintf(fp, "stf");
01996 switch(fldst.size)
01997 {
01998 case FLSS_S: fprintf(fp, "s");
01999 break;
02000 case FLSS_D: fprintf(fp, "d");
02001 break;
02002 case FLSS_E: fprintf(fp, "e");
02003 break;
02004 case FLSS_I: fprintf(fp, "8");
02005 break;
02006 case FLSS_NONE: break;
02007 }
02008 switch(fldst.type)
02009 {
02010 case LST_SPILL: fprintf(fp, ".spill");
02011 break;
02012 case LST_NONE: break;
02013 }
02014 switch(fldst.hint)
02015 {
02016 case LSH_NTA: fprintf(fp, ".nta");
02017 break;
02018 case LSH_NONE: break;
02019 }
02020 WriteLDFOprd(op);
02021 break;
02022 }
02023 fprintf(fp, "\n");
02024 }
02025
02026 void WriteFpCmpOp(legoOp *op)
02027 {
02028 fcmpQuals fcmp;
02029
02030 fcmp = Opcode->GetFcmpQuals();
02031
02032 switch(op->GetOpcode())
02033 {
02034 case FCMP: fprintf(fp, "fcmp");
02035 switch(fcmp.relation)
02036 {
02037 case FCR_EQ: fprintf(fp, ".eq");
02038 break;
02039 case FCR_NEQ: fprintf(fp, ".neq");
02040 break;
02041 case FCR_LT: fprintf(fp, ".lt");
02042 break;
02043 case FCR_NLT: fprintf(fp, ".nlt");
02044 break;
02045 case FCR_LE: fprintf(fp, ".le");
02046 break;
02047 case FCR_NLE: fprintf(fp, ".nle");
02048 break;
02049 case FCR_GT: fprintf(fp, ".gt");
02050 break;
02051 case FCR_NGT: fprintf(fp, ".ngt");
02052 break;
02053 case FCR_GE: fprintf(fp, ".ge");
02054 break;
02055 case FCR_NGE: fprintf(fp, ".nge");
02056 break;
02057 case FCR_UNORD: fprintf(fp, ".unord");
02058 break;
02059 case FCR_ORD: fprintf(fp, ".ord");
02060 break;
02061 }
02062 switch(fcmp.type)
02063 {
02064 case FCT_UNC: fprintf(fp, ".unc");
02065 break;
02066 case FCT_NONE: break;
02067 }
02068 switch(fcmp.sfield)
02069 {
02070 case FPSF_F0: fprintf(fp, ".s0");
02071 break;
02072 case FPSF_F1: fprintf(fp, ".s1");
02073 break;
02074 case FPSF_F2: fprintf(fp, ".s2");
02075 break;
02076 case FPSF_F3: fprintf(fp, ".s3");
02077 break;
02078 case FPSF_NONE: break;
02079 }
02080 WriteFCmpOprd(op);
02081 break;
02082 case FCLASS: fprintf(fp, "fclass");
02083 switch(fcmp.classrelation)
02084 {
02085 case FPCR_M: fprintf(fp, ".m");
02086 break;
02087 case FPCR_NM: fprintf(fp, ".nm");
02088 break;
02089 }
02090 switch(fcmp.type)
02091 {
02092 case FCT_UNC: fprintf(fp, ".unc");
02093 break;
02094 case FCT_NONE: break;
02095 }
02096 WriteFCmpOprd(op);
02097 break;
02098 }
02099 fprintf(fp, "\n");
02100 }
02101
02102 void WriteMiscOp(legoOp *op)
02103 {
02104 miscQuals misc;
02105
02106 misc = Opcode->GetMiscQuals();
02107
02108 legoOprd *dest, *src;
02109 int counter;
02110
02111 switch(op->GetOpcode())
02112 {
02113 case ALLOC: fprintf(fp, "alloc");
02114 for(dest = op->GetDestOprdPtr(); dest != NULL;
02115 dest = dest->GetNextOprdPtr())
02116 {
02117 if(dest->GetOprdType() == OT_REG)
02118 {
02119 fprintf(fp, " r%d", dest->GetOprdRegNum());
02120 }
02121
02122
02123
02124
02125
02126
02127
02128
02129 }
02130
02131 fprintf(fp, " =");
02132
02133 for(src = op->GetSrcOprdPtr(), counter = 0; src != NULL;
02134 src = src->GetNextOprdPtr())
02135 {
02136
02137 switch(src->GetOprdType())
02138 {
02139 case OT_LITERAL_S: switch(counter)
02140 {
02141 case 0: fprintf(fp, " %s",
02142 src->GetLiteralString());
02143 counter++;
02144 break;
02145 case 4:
02146 case 3:
02147 case 1:
02148 case 2: fprintf(fp, ", %s",
02149 src->GetLiteralString());
02150 counter++;
02151 break;
02152 }
02153 break;
02154 case OT_LITERAL_LLNG: switch(counter)
02155 {
02156 case 0: fprintf(fp, " %lld",
02157 src->GetLiteralLongLong());
02158 counter++;
02159 break;
02160 case 4:
02161 case 3:
02162 case 1:
02163 case 2: fprintf(fp, ", %lld",
02164 src->GetLiteralLongLong());
02165 counter++;
02166 break;
02167 }
02168 break;
02169 default: LegoFatal("IA64Write",
02170 "Alloc have src oprd that is not a literal.");
02171 exit(1);
02172 }
02173 }
02174 break;
02175 case NOP: fprintf(fp, "nop");
02176 for(dest = op->GetDestOprdPtr(); dest != NULL;
02177 dest = dest->GetNextOprdPtr())
02178 {
02179 switch(dest->GetOprdType())
02180 {
02181 case OT_LITERAL_S: fprintf(fp, " %s",
02182 dest->GetLiteralString());
02183 counter++;
02184 break;
02185
02186 break;
02187 case OT_LITERAL_LLNG: fprintf(fp, " %lld",
02188 dest->GetLiteralLongLong());
02189 counter++;
02190 break;
02191
02192
02193 default: LegoFatal("IA64Write",
02194 "NOP have dest oprd that is not a literal.");
02195 exit(1);
02196 }
02197
02198 }
02199 break;
02200 case BREAK: fprintf(fp, "break");
02201
02202 switch(misc.breakUnit)
02203 {
02204 case OFMU_I:
02205 fprintf(fp, ".i");
02206 break;
02207 case OFMU_B:
02208 fprintf(fp, ".b");
02209 break;
02210 case OFMU_M:
02211 fprintf(fp, ".m");
02212 break;
02213 case OFMU_F:
02214 fprintf(fp, ".f");
02215 break;
02216 case OFMU_X:
02217 fprintf(fp, ".x");
02218 break;
02219 case OFMU_NONE:
02220 break;
02221 }
02222
02223 for(src = op->GetSrcOprdPtr(); src != NULL;
02224 src = src->GetNextOprdPtr())
02225 {
02226 switch(src->GetOprdType())
02227 {
02228 case OT_LITERAL_LLNG: fprintf(fp, " %lld",
02229 src->GetLiteralLongLong());
02230 break;
02231
02232 default: LegoFatal("IA64Write",
02233 "BREAK has src oprd that is not a literal long long.");
02234 exit(1);
02235 }
02236
02237 }
02238 break;
02239 }
02240 fprintf(fp, "\n");
02241 }
02242
02243 void IA64WriteVariable(nameTable * var, FILE *out)
02244 {
02245 fprintf(out, "%s", var->GetInfo());
02246 }
02247
02248 void IA64WriteData1Seg(symbolTable * sym, FILE *out)
02249 {
02250 for(int i=0; i < sym->GetVarCount();i++) {
02251 if (sym->GetVarTablePtr(i)->GetImportType() == LIR_GNU_WEAK) {
02252 fprintf(out, ".weak %s#\n", sym->GetVarTablePtr(i)->GetVarName());
02253 fprintf(out, ".section .gnu.linkonce.r.%s,\"a\",@progbits\n", sym->GetVarTablePtr(i)->GetVarName());
02254 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02255 }
02256 else {
02257 fprintf(out, ".section .rodata\n");
02258 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02259 }
02260 }
02261 }
02262
02263 void IA64WriteDataSeg(symbolTable * sym, FILE *out)
02264 {
02265 for(int i=0; i < sym->GetVarCount();i++) {
02266 if (sym->GetVarTablePtr(i)->GetImportType() == LIR_GNU_WEAK) {
02267 fprintf(out, ".weak %s#\n", sym->GetVarTablePtr(i)->GetVarName());
02268 fprintf(out, ".section .gnu.linkonce.d.%s,\"aw\",@progbits\n", sym->GetVarTablePtr(i)->GetVarName());
02269 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02270 }
02271 else {
02272 fprintf(out, ".data\n");
02273 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02274 }
02275 }
02276 }
02277
02278 void IA64WriteSDataSeg(symbolTable * sym, FILE *out)
02279 {
02280 fprintf(out, ".sdata\n");
02281 for(int i=0; i < sym->GetVarCount();i++)
02282 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02283 }
02284
02285 void IA64WriteBssSeg(symbolTable * sym, FILE *out)
02286 {
02287 fprintf(out, ".bss\n");
02288 for(int i=0; i < sym->GetVarCount();i++)
02289 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02290 }
02291
02292 void IA64WriteSBssSeg(symbolTable * sym, FILE *out)
02293 {
02294 fprintf(out, ".sbss\n");
02295 for(int i=0; i < sym->GetVarCount();i++)
02296 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02297 }
02298
02299 void IA64WriteCommentSeg(symbolTable * sym, FILE *out)
02300 {
02301
02302 for(int i=0; i < sym->GetVarCount();i++)
02303 IA64WriteVariable(sym->GetVarTablePtr(i), out);
02304 }
02305
02306 void IA64WriteCtorsSeg(legoProc *proc)
02307 {
02308 attrList *alc;
02309 attrs *a;
02310 char *directive;
02311
02312 alc = proc->GetRegionAttrListPtr();
02313
02314 for(; alc != NULL; alc = alc->GetNextListPtr())
02315 {
02316 a = alc->GetAttrPtr();
02317 if(!a) continue;
02318
02319 if(a->GetAttrType() == ATTR_LC)
02320 {
02321 for(a = alc->GetAttrPtr(); a != NULL;
02322 a = a->GetNextLcEntryPtr())
02323 {
02324 if(strncmp(a->GetAttrString(),
02325 "ctor_declaration:", 17) == 0)
02326 {
02327 directive = a->GetAttrString() +
02328 strlen("ctor_declaration:");
02329 fprintf(fp, ".section .ctors,\"aw\",@progbits\n");
02330 fprintf(fp, "%s", directive);
02331 }
02332 }
02333 }
02334
02335 }
02336 }
02337
02338 void IA64WriteDtorsSeg(legoProc *proc)
02339 {
02340 attrList *alc;
02341 attrs *a;
02342 char *directive;
02343
02344 alc = proc->GetRegionAttrListPtr();
02345
02346 for(; alc != NULL; alc = alc->GetNextListPtr())
02347 {
02348 a = alc->GetAttrPtr();
02349 if(!a) continue;
02350
02351 if(a->GetAttrType() == ATTR_LC)
02352 {
02353 for(a = alc->GetAttrPtr(); a != NULL;
02354 a = a->GetNextLcEntryPtr())
02355 {
02356 if(strncmp(a->GetAttrString(),
02357 "dtor_declaration:", 17) == 0)
02358 {
02359 directive = a->GetAttrString() +
02360 strlen("dtor_declaration:");
02361 fprintf(fp, ".section .dtors,\"aw\",@progbits\n");
02362 fprintf(fp, "%s", directive);
02363 }
02364 }
02365 }
02366
02367 }
02368 }
02369
02370 void WriteGroupEnd(legoOp * op)
02371 {
02372 attrList *alc;
02373 attrs *a;
02374 char *directive;
02375
02376 alc = op->GetOpAttrListPtr();
02377
02378 for(; alc != NULL; alc = alc->GetNextListPtr())
02379 {
02380 a = alc->GetAttrPtr();
02381 if(!a) continue;
02382
02383 if(a->GetAttrType() == ATTR_LC)
02384 {
02385 for(a = alc->GetAttrPtr(); a != NULL;
02386 a = a->GetNextLcEntryPtr())
02387 {
02388 if(strncmp(a->GetAttrString(),
02389 "group_end:", 10) == 0)
02390 {
02391 fprintf(fp, "\t;;\n");
02392 }
02393 }
02394 }
02395
02396 }
02397 }
02398
02399
02400 void IA64RegionWrite(legoRegion * Region, legoProc *Proc)
02401 {
02402 int i;
02403 switch(Region->GetRegionType())
02404 {
02405 case RT_TREE:
02406 for(i = 0; i < Region->GetCount(); i++)
02407 {
02408 legoRegion *region = (legoRegion *)Region->GetItem(i);
02409 IA64RegionWrite(region, Proc);
02410 }
02411 break;
02412 case RT_BB:
02413 {
02414 legoOp * op = Region->GetEntryOpsPtr()->GetOpPtr();
02415 for(; op != NULL; op = op->GetNextLink())
02416 {
02417
02418
02419 WriteDirective(op);
02420
02421
02422
02423 WritePredicateOprd(op);
02424
02425 Opcode = op->GetOpcodePtr();
02426
02427 if(Opcode->GetOpcodeClass() == OC_BR)
02428 {
02429 fprintf(fp, "\t");
02430 WriteBrOp(op, Proc);
02431 WriteJTBL(op);
02432 }
02433
02434 else if(Opcode->GetOpcodeClass() == OC_CMP)
02435 {
02436 fprintf(fp, "\t");
02437 WriteCmpOp(op);
02438 }
02439
02440 else if(Opcode->GetOpcodeClass() == OC_INT)
02441 {
02442 fprintf(fp, "\t");
02443 WriteIntOp(op);
02444 }
02445 else if(Opcode->GetOpcodeClass() == OC_LDST)
02446 {
02447 fprintf(fp, "\t");
02448 WriteIldstOp(op);
02449 }
02450 else if(Opcode->GetOpcodeClass() == OC_FP)
02451 {
02452 fprintf(fp, "\t");
02453 WriteFpOp(op);
02454 }
02455 else if(Opcode->GetOpcodeClass() == OC_FCMP)
02456 {
02457 fprintf(fp, "\t");
02458 WriteFpCmpOp(op);
02459 }
02460 else if(Opcode->GetOpcodeClass() == OC_FPLDST)
02461 {
02462 fprintf(fp, "\t");
02463 WriteFpLdstOp(op);
02464 }
02465 else if(Opcode->GetOpcodeClass() == OC_UNDEF)
02466 {
02467 if(op->GetOpcode() == NO_OP)
02468 fprintf(fp, "\t;;\n");
02469
02470 else if(op->IsCMERGEOp())
02471 {
02472 legoOprd *dest;
02473 dest = op->GetDestOprdPtr();
02474 if(dest != NULL)
02475 {
02476 if(dest->GetOprdType() ==
02477 OT_LITERAL_S)
02478 {
02479 fprintf(fp, ".%s:\n",
02480 dest->GetLiteralString());
02481 }
02482
02483
02484
02485
02486
02487 if(dest->GetOprdType() ==
02488 OT_LITERAL_CB)
02489 fprintf(fp, ".C_%s_B%d:\n", Proc->GetProcName(), dest->GetLiteralControlBlock());
02490 }
02491 }
02492 }
02493 else if(Opcode->GetOpcodeClass() == OC_MISC)
02494 {
02495 fprintf(fp, "\t");
02496 WriteMiscOp(op);
02497 }
02498
02499 WriteGroupEnd(op);
02500 }
02501 }
02502 break;
02503 default:
02504 fprintf(stderr, "Error: IA64RegionWrite region type not supported.\n");
02505 exit(-1);
02506 }
02507 }
02508
02509 int IA64Write (legoModule *Module, char *infile)
02510 {
02511
02512 legoProc *Proc;
02513 legoRegion *Region;
02514 legoOp *op;
02515 vector <char *> * cmts;
02516 vector <char *>::iterator comi;
02517 bool anyWeak = false;
02518
02519 if(!Module)
02520 {
02521 LegoFatal("IA64Wrt", "Module is a null pointer\n");
02522 return 1;
02523 }
02524
02525 fp = fopen(infile, "w");
02526
02527
02528
02529
02530
02531
02532 fprintf(fp, ".file ");
02533
02534
02535 cmts = Module->GetComments();
02536 if(cmts != NULL)
02537 {
02538 for (comi = cmts->begin(); comi != cmts->end(); comi++)
02539 {
02540 if(strstr(*comi, "//IA: ") != NULL)
02541 fprintf(fp, "%s", *comi + strlen("//IA: "));
02542
02543 else if(strstr(*comi, "//Global: ") != NULL)
02544 fprintf(fp, "%s", *comi + strlen("//Global: "));
02545 }
02546 }
02547
02548
02549 if(Module->GetData1Ptr() != NULL)
02550 IA64WriteData1Seg(Module->GetData1Ptr(), fp);
02551 if(Module->GetDataPtr() != NULL)
02552 IA64WriteDataSeg(Module->GetDataPtr(), fp);
02553 if(Module->GetSDataPtr() != NULL)
02554 IA64WriteSDataSeg(Module->GetSDataPtr(), fp);
02555 if(Module->GetBssPtr() != NULL)
02556 IA64WriteBssSeg(Module->GetBssPtr(), fp);
02557 if(Module->GetSBssPtr() != NULL)
02558 IA64WriteSBssSeg(Module->GetSBssPtr(), fp);
02559
02560
02561 if(Module->GetCommentPtr() != NULL)
02562 IA64WriteCommentSeg(Module->GetCommentPtr(), fp);
02563
02564
02565
02566 for(int i = 0; i < Module->GetCount(); i++)
02567 {
02568 Proc = (legoProc *) Module->GetItem(i);
02569
02570 if(Proc->GetInfo() != NULL)
02571 fprintf(fp, "%s", Proc->GetInfo());
02572
02573 if (Proc->GetScope() == LIR_GNU_WEAK) {
02574 anyWeak = true;
02575 fprintf(fp, "\t.section .gnu.linkonce.t.%s,\"ax\",@progbits\n",
02576 Proc->GetProcName());
02577 fprintf(fp, "\t.align 16\n\t.weak %s#\n\t.proc %s#\n",
02578 Proc->GetProcName(), Proc->GetProcName());
02579 fprintf(fp, "%s:\n", Proc->GetProcName());
02580 }
02581 else {
02582 fprintf(fp, ".text\n");
02583 if(Proc->GetScope() == LIR_GLOBAL)
02584 {
02585 fprintf(fp, "\t.align 16\n\t.global %s#\n\t.proc %s#\n",
02586 Proc->GetProcName(), Proc->GetProcName());
02587 }
02588 else
02589 {
02590 fprintf(fp, "\t.align 16\n\t.proc %s#\n",
02591 Proc->GetProcName(), Proc->GetProcName());
02592 }
02593 fprintf(fp, "%s:\n", Proc->GetProcName());
02594 }
02595
02596 for(int j = 0; j < Proc->GetCount(); j++)
02597 {
02598 Region = (legoRegion *) Proc->GetItem(j);
02599
02600 IA64RegionWrite(Region, Proc);
02601 }
02602 WriteEndpDirective(Proc);
02603 fprintf(fp, "\t.endp %s#\n", Proc->GetProcName());
02604 IA64WriteCtorsSeg(Proc);
02605 IA64WriteDtorsSeg(Proc);
02606
02607 }
02608
02609 if (anyWeak) {
02610 fprintf(fp, "%s", "\t.weak pthread_mutex_unlock#\n\t.weak pthread_mutex_trylock#\n\t.weak pthread_mutex_lock#\n\t.weak pthread_create#\n\t.weak pthread_setspecific#\n\t.weak pthread_getspecific#\n\t.weak pthread_key_delete#\n\t.weak pthread_key_create#\n\t.weak pthread_once#\n\t.ident \"GCC: (GNU) 3.1\"\n");
02611 }
02612
02613
02614
02615
02616 fclose(fp);
02617 return 0;
02618 }
