proplong.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567
  1. /**************************************************************************
  2. * File : propLong.c
  3. * Purpose: propagate the value of long variables (local variables and
  4. * registers) along the graph. Structure the graph in this way.
  5. * (C) Cristina Cifuentes
  6. **************************************************************************/
  7. #include "dcc.h"
  8. #include "string.h"
  9. #ifdef __BORLAND__
  10. #include <mem.h>
  11. #else
  12. #include <memory.h>
  13. #endif
  14. static boolT isJCond (llIcode opcode)
  15. /* Returns whether the given icode opcode is within the range of valid
  16. * high-level conditional jump icodes (iJB..iJG) */
  17. {
  18. if ((opcode >= iJB) && (opcode <= iJG))
  19. return (TRUE);
  20. return (FALSE);
  21. }
  22. static boolT isLong23 (Int i, PBB pbb, PICODE icode, Int *off, Int *arc)
  23. /* Returns whether the conditions for a 2-3 long variable are satisfied */
  24. { PBB t, e, obb2;
  25. if (pbb->nodeType != TWO_BRANCH)
  26. return (FALSE);
  27. t = pbb->edges[THEN].BBptr;
  28. e = pbb->edges[ELSE].BBptr;
  29. /* Check along the THEN path */
  30. if ((t->length == 1) && (t->nodeType == TWO_BRANCH) && (t->numInEdges == 1))
  31. {
  32. obb2 = t->edges[THEN].BBptr;
  33. if ((obb2->length == 2) && (obb2->nodeType == TWO_BRANCH) &&
  34. (icode[obb2->start].ic.ll.opcode == iCMP))
  35. {
  36. *off = obb2->start - i;
  37. *arc = THEN;
  38. return (TRUE);
  39. }
  40. }
  41. /* Check along the ELSE path */
  42. else if ((e->length == 1) && (e->nodeType == TWO_BRANCH) &&
  43. (e->numInEdges == 1))
  44. {
  45. obb2 = e->edges[THEN].BBptr;
  46. if ((obb2->length == 2) && (obb2->nodeType == TWO_BRANCH) &&
  47. (icode[obb2->start].ic.ll.opcode == iCMP))
  48. {
  49. *off = obb2->start - i;
  50. *arc = ELSE;
  51. return (TRUE);
  52. }
  53. }
  54. return (FALSE);
  55. }
  56. static boolT isLong22 (PICODE pIcode, PICODE pEnd, Int *off)
  57. /* Returns whether the conditions for a 2-2 long variable are satisfied */
  58. {
  59. if (((pIcode+2) < pEnd) && ((pIcode+2)->ic.ll.opcode == iCMP) &&
  60. (isJCond ((pIcode+1)->ic.ll.opcode)) &&
  61. (isJCond ((pIcode+3)->ic.ll.opcode)))
  62. {
  63. *off = 2;
  64. return (TRUE);
  65. }
  66. return (FALSE);
  67. }
  68. static void longJCond23 (COND_EXPR *rhs, COND_EXPR *lhs, PICODE pIcode,
  69. Int *idx, PPROC pProc, Int arc, Int off)
  70. /* Creates a long conditional <=, >=, <, or > at (pIcode+1).
  71. * Removes excess nodes from the graph by flagging them, and updates
  72. * the new edges for the remaining nodes. */
  73. { Int j;
  74. PBB pbb, obb1, obb2, tbb;
  75. if (arc == THEN)
  76. {
  77. /* Find intermediate basic blocks and target block */
  78. pbb = pIcode->inBB;
  79. obb1 = pbb->edges[THEN].BBptr;
  80. obb2 = obb1->edges[THEN].BBptr;
  81. tbb = obb2->edges[THEN].BBptr;
  82. /* Modify out edge of header basic block */
  83. pbb->edges[THEN].BBptr = tbb;
  84. /* Modify in edges of target basic block */
  85. for (j = 0; j < (tbb->numInEdges-1); j++)
  86. {
  87. if ((tbb->inEdges[j] == obb1) || (tbb->inEdges[j] == obb2))
  88. {
  89. memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  90. (tbb->numInEdges - j-1) * sizeof(PBB));
  91. memset (&tbb->inEdges[tbb->numInEdges-1], ' ',sizeof (PBB));
  92. j--;
  93. }
  94. }
  95. tbb->numInEdges--; /* looses 2 arcs, gains 1 arc */
  96. tbb->inEdges[tbb->numInEdges-1] = pbb;
  97. /* Modify in edges of the ELSE basic block */
  98. tbb = pbb->edges[ELSE].BBptr;
  99. for (j = 0; j < (tbb->numInEdges-1); j++)
  100. {
  101. if (tbb->inEdges[j] == obb2)
  102. {
  103. memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  104. (tbb->numInEdges - j-1) * sizeof(PBB));
  105. break;
  106. }
  107. }
  108. tbb->numInEdges--; /* looses 1 arc */
  109. /* Update icode index */
  110. (*idx) += 5;
  111. }
  112. else /* ELSE arc */
  113. {
  114. /* Find intermediate basic blocks and target block */
  115. pbb = pIcode->inBB;
  116. obb1 = pbb->edges[ELSE].BBptr;
  117. obb2 = obb1->edges[THEN].BBptr;
  118. tbb = obb2->edges[THEN].BBptr;
  119. /* Modify in edges of target basic block */
  120. for (j = 0; j < (tbb->numInEdges-1); j++)
  121. {
  122. if (tbb->inEdges[j] == obb2)
  123. {
  124. memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  125. (tbb->numInEdges - j-1) * sizeof(PBB));
  126. break;
  127. }
  128. }
  129. tbb->numInEdges--; /* looses 1 arc */
  130. /* Modify in edges of the ELSE basic block */
  131. tbb = obb2->edges[ELSE].BBptr;
  132. for (j = 0; j < (tbb->numInEdges-1); j++)
  133. {
  134. if ((tbb->inEdges[j] == obb2) || (tbb->inEdges[j] == obb1))
  135. {
  136. memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  137. (tbb->numInEdges - j-1) * sizeof(PBB));
  138. memset (&tbb->inEdges[tbb->numInEdges-1], ' ',sizeof (PBB));
  139. j--;
  140. }
  141. }
  142. tbb->numInEdges--; /* looses 2 arcs, gains 1 arc */
  143. tbb->inEdges[tbb->numInEdges - 1] = pbb;
  144. /* Modify out edge of header basic block */
  145. pbb->edges[ELSE].BBptr = tbb;
  146. /* Update icode index */
  147. (*idx) += 2;
  148. }
  149. /* Create new HLI_JCOND and condition */
  150. lhs = boolCondExp (lhs, rhs, condOpJCond[(pIcode+off+1)->ic.ll.opcode-iJB]);
  151. newJCondHlIcode (pIcode+1, lhs);
  152. copyDU (pIcode+1, pIcode, E_USE, E_USE);
  153. (pIcode+1)->du.use |= (pIcode+off)->du.use;
  154. /* Update statistics */
  155. obb1->flg |= INVALID_BB;
  156. obb2->flg |= INVALID_BB;
  157. stats.numBBaft -= 2;
  158. invalidateIcode (pIcode);
  159. invalidateIcode (pProc->Icode.GetIcode(obb1->start));
  160. invalidateIcode (pProc->Icode.GetIcode(obb2->start));
  161. invalidateIcode (pProc->Icode.GetIcode(obb2->start+1));
  162. }
  163. static void longJCond22 (COND_EXPR *rhs, COND_EXPR *lhs, PICODE pIcode,
  164. Int *idx)
  165. /* Creates a long conditional equality or inequality at (pIcode+1).
  166. * Removes excess nodes from the graph by flagging them, and updates
  167. * the new edges for the remaining nodes. */
  168. { Int j;
  169. PBB pbb, obb1, tbb;
  170. /* Form conditional expression */
  171. lhs = boolCondExp (lhs, rhs, condOpJCond[(pIcode+3)->ic.ll.opcode - iJB]);
  172. newJCondHlIcode (pIcode+1, lhs);
  173. copyDU (pIcode+1, pIcode, E_USE, E_USE);
  174. (pIcode+1)->du.use |= (pIcode+2)->du.use;
  175. /* Adjust outEdges[0] to the new target basic block */
  176. pbb = pIcode->inBB;
  177. if ((pbb->start + pbb->length - 1) == (*idx + 1))
  178. {
  179. /* Find intermediate and target basic blocks */
  180. obb1 = pbb->edges[THEN].BBptr;
  181. tbb = obb1->edges[THEN].BBptr;
  182. /* Modify THEN out edge of header basic block */
  183. pbb->edges[THEN].BBptr = tbb;
  184. /* Modify in edges of target basic block */
  185. for (j = 0; j < (tbb->numInEdges-1); j++)
  186. {
  187. if (tbb->inEdges[j] == obb1)
  188. {
  189. memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  190. (tbb->numInEdges - j-1) * sizeof(PBB));
  191. break;
  192. }
  193. }
  194. if ((pIcode+3)->ic.ll.opcode == iJE)
  195. tbb->numInEdges--; /* looses 1 arc */
  196. else /* iJNE => replace arc */
  197. tbb->inEdges[tbb->numInEdges-1] = pbb;
  198. /* Modify ELSE out edge of header basic block */
  199. tbb = obb1->edges[ELSE].BBptr;
  200. pbb->edges[ELSE].BBptr = tbb;
  201. /* Modify in edges of the ELSE basic block */
  202. for (j = 0; j < (tbb->numInEdges-1); j++)
  203. {
  204. if (tbb->inEdges[j] == obb1)
  205. {
  206. memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  207. (tbb->numInEdges - j-1) * sizeof(PBB));
  208. break;
  209. }
  210. }
  211. if ((pIcode+3)->ic.ll.opcode == iJE) /* replace */
  212. tbb->inEdges[tbb->numInEdges-1] = pbb;
  213. else
  214. tbb->numInEdges--; /* iJNE => looses 1 arc */
  215. /* Update statistics */
  216. obb1->flg |= INVALID_BB;
  217. stats.numBBaft--;
  218. }
  219. invalidateIcode (pIcode);
  220. invalidateIcode (pIcode+2);
  221. invalidateIcode (pIcode+3);
  222. (*idx) += 4;
  223. }
  224. static void propLongStk (Int i, ID *pLocId, PPROC pProc)
  225. /* Propagates TYPE_LONG_(UN)SIGN icode information to the current pIcode
  226. * Pointer.
  227. * Arguments: i : index into the local identifier table
  228. * pLocId: ptr to the long local identifier
  229. * pProc : ptr to current procedure's record. */
  230. { Int idx, off, arc;
  231. COND_EXPR *lhs, *rhs; /* Pointers to left and right hand expression */
  232. PICODE pIcode, pEnd;
  233. /* Check all icodes for offHi:offLo */
  234. pEnd = pProc->Icode.GetIcode(pProc->Icode.GetNumIcodes() -1);
  235. for (idx = 0; idx < (pProc->Icode.GetNumIcodes() - 1); idx++)
  236. {
  237. pIcode = pProc->Icode.GetIcode(idx);
  238. if ((pIcode->type == HIGH_LEVEL) || (pIcode->invalid == TRUE))
  239. continue;
  240. if (pIcode->ic.ll.opcode == (pIcode+1)->ic.ll.opcode)
  241. {
  242. switch (pIcode->ic.ll.opcode) {
  243. case iMOV:
  244. if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  245. &rhs, &lhs, 1) == TRUE)
  246. {
  247. newAsgnHlIcode (pIcode, lhs, rhs);
  248. invalidateIcode (pIcode + 1);
  249. idx++;
  250. }
  251. break;
  252. case iAND: case iOR: case iXOR:
  253. if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  254. &rhs, &lhs, 1) == TRUE)
  255. {
  256. switch (pIcode->ic.ll.opcode) {
  257. case iAND: rhs = boolCondExp (lhs, rhs, AND);
  258. break;
  259. case iOR: rhs = boolCondExp (lhs, rhs, OR);
  260. break;
  261. case iXOR: rhs = boolCondExp (lhs, rhs, XOR);
  262. break;
  263. }
  264. newAsgnHlIcode (pIcode, lhs, rhs);
  265. invalidateIcode (pIcode + 1);
  266. idx++;
  267. }
  268. break;
  269. case iPUSH:
  270. if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  271. &rhs, &lhs, 1) == TRUE)
  272. {
  273. newUnaryHlIcode (pIcode, HLI_PUSH, lhs);
  274. invalidateIcode (pIcode + 1);
  275. idx++;
  276. }
  277. break;
  278. } /*eos*/
  279. }
  280. /* Check long conditional (i.e. 2 CMPs and 3 branches */
  281. else if ((pIcode->ic.ll.opcode == iCMP) &&
  282. (isLong23 (idx, pIcode->inBB, pProc->Icode.GetFirstIcode(),
  283. &off, &arc)))
  284. {
  285. if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  286. &rhs, &lhs, off) == TRUE)
  287. longJCond23 (rhs, lhs, pIcode, &idx, pProc, arc, off);
  288. }
  289. /* Check for long conditional equality or inequality. This requires
  290. * 2 CMPs and 2 branches */
  291. else if ((pIcode->ic.ll.opcode == iCMP) &&
  292. isLong22 (pIcode, pEnd, &off))
  293. {
  294. if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  295. &rhs, &lhs, off) == TRUE)
  296. longJCond22 (rhs, lhs, pIcode, &idx);
  297. }
  298. }
  299. }
  300. static void propLongReg (Int i, ID *pLocId, PPROC pProc)
  301. /* Finds the definition of the long register pointed to by pLocId, and
  302. * transforms that instruction into a HIGH_LEVEL icode instruction.
  303. * Arguments: i : index into the local identifier table
  304. * pLocId: ptr to the long local identifier
  305. * pProc : ptr to current procedure's record. */
  306. { COND_EXPR *lhs, *rhs;
  307. Int idx, j, off, arc;
  308. PICODE pIcode, pEnd;
  309. PMEM pmH, pmL; /* Pointers to dst LOW_LEVEL icodes */
  310. /* Process all definitions/uses of long registers at an icode position */
  311. pEnd = pProc->Icode.GetIcode(pProc->Icode.GetNumIcodes() -1);
  312. for (j = 0; j < pLocId->idx.csym; j++)
  313. {
  314. /* Check backwards for a definition of this long register */
  315. for (idx = pLocId->idx.idx[j] - 1; idx > 0 ; idx--)
  316. {
  317. pIcode = pProc->Icode.GetIcode(idx-1);
  318. if ((pIcode->type == HIGH_LEVEL) || (pIcode->invalid == TRUE))
  319. continue;
  320. if (pIcode->ic.ll.opcode == (pIcode+1)->ic.ll.opcode)
  321. switch (pIcode->ic.ll.opcode) {
  322. case iMOV:
  323. pmH = &pIcode->ic.ll.dst;
  324. pmL = &(pIcode+1)->ic.ll.dst;
  325. if ((pLocId->id.longId.h == pmH->regi) &&
  326. (pLocId->id.longId.l == pmL->regi))
  327. {
  328. lhs = idCondExpLongIdx (i);
  329. insertIdx (&pProc->localId.id[i].idx, idx-1);
  330. setRegDU (pIcode, pmL->regi, E_DEF);
  331. rhs = idCondExpLong (&pProc->localId, SRC, pIcode, HIGH_FIRST,
  332. idx, E_USE, 1);
  333. newAsgnHlIcode (pIcode, lhs, rhs);
  334. invalidateIcode (pIcode + 1);
  335. idx = 0; /* to exit the loop */
  336. }
  337. break;
  338. case iPOP:
  339. pmH = &(pIcode+1)->ic.ll.dst;
  340. pmL = &pIcode->ic.ll.dst;
  341. if ((pLocId->id.longId.h == pmH->regi) &&
  342. (pLocId->id.longId.l == pmL->regi))
  343. {
  344. lhs = idCondExpLongIdx (i);
  345. setRegDU (pIcode, pmH->regi, E_DEF);
  346. newUnaryHlIcode (pIcode, HLI_POP, lhs);
  347. invalidateIcode (pIcode + 1);
  348. idx = 0; /* to exit the loop */
  349. }
  350. break;
  351. /**** others missing ***/
  352. case iAND: case iOR: case iXOR:
  353. pmL = &pIcode->ic.ll.dst;
  354. pmH = &(pIcode+1)->ic.ll.dst;
  355. if ((pLocId->id.longId.h == pmH->regi) &&
  356. (pLocId->id.longId.l == pmL->regi))
  357. {
  358. lhs = idCondExpLongIdx (i);
  359. setRegDU (pIcode, pmH->regi, USE_DEF);
  360. rhs = idCondExpLong (&pProc->localId, SRC, pIcode, LOW_FIRST,
  361. idx, E_USE, 1);
  362. switch (pIcode->ic.ll.opcode) {
  363. case iAND: rhs = boolCondExp (lhs, rhs, AND);
  364. break;
  365. case iOR: rhs = boolCondExp (lhs, rhs, OR);
  366. break;
  367. case iXOR: rhs = boolCondExp (lhs, rhs, XOR);
  368. break;
  369. } /* eos */
  370. newAsgnHlIcode (pIcode, lhs, rhs);
  371. invalidateIcode (pIcode + 1);
  372. idx = 0;
  373. }
  374. break;
  375. } /* eos */
  376. }
  377. /* If no definition backwards, check forward for a use of this long reg */
  378. if (idx <= 0)
  379. for (idx = pLocId->idx.idx[j] + 1; idx < pProc->Icode.GetNumIcodes() - 1; idx++)
  380. {
  381. pIcode = pProc->Icode.GetIcode(idx);
  382. if ((pIcode->type == HIGH_LEVEL) || (pIcode->invalid == TRUE))
  383. continue;
  384. if (pIcode->ic.ll.opcode == (pIcode+1)->ic.ll.opcode)
  385. switch (pIcode->ic.ll.opcode) {
  386. case iMOV:
  387. if ((pLocId->id.longId.h == pIcode->ic.ll.src.regi) &&
  388. (pLocId->id.longId.l == (pIcode+1)->ic.ll.src.regi))
  389. {
  390. rhs = idCondExpLongIdx (i);
  391. setRegDU (pIcode, (pIcode+1)->ic.ll.src.regi, E_USE);
  392. lhs = idCondExpLong (&pProc->localId, DST, pIcode,
  393. HIGH_FIRST, idx, E_DEF, 1);
  394. newAsgnHlIcode (pIcode, lhs, rhs);
  395. invalidateIcode (pIcode + 1);
  396. idx = pProc->Icode.GetNumIcodes(); /* to exit the loop */
  397. }
  398. break;
  399. case iPUSH:
  400. if ((pLocId->id.longId.h == pIcode->ic.ll.src.regi) &&
  401. (pLocId->id.longId.l == (pIcode+1)->ic.ll.src.regi))
  402. {
  403. rhs = idCondExpLongIdx (i);
  404. setRegDU (pIcode, (pIcode+1)->ic.ll.src.regi, E_USE);
  405. newUnaryHlIcode (pIcode, HLI_PUSH, lhs);
  406. invalidateIcode (pIcode + 1);
  407. }
  408. idx = pProc->Icode.GetNumIcodes(); /* to exit the loop */
  409. break;
  410. /*** others missing ****/
  411. case iAND: case iOR: case iXOR:
  412. pmL = &pIcode->ic.ll.dst;
  413. pmH = &(pIcode+1)->ic.ll.dst;
  414. if ((pLocId->id.longId.h == pmH->regi) &&
  415. (pLocId->id.longId.l == pmL->regi))
  416. {
  417. lhs = idCondExpLongIdx (i);
  418. setRegDU (pIcode, pmH->regi, USE_DEF);
  419. rhs = idCondExpLong (&pProc->localId, SRC, pIcode,
  420. LOW_FIRST, idx, E_USE, 1);
  421. switch (pIcode->ic.ll.opcode) {
  422. case iAND: rhs = boolCondExp (lhs, rhs, AND);
  423. break;
  424. case iOR: rhs = boolCondExp (lhs, rhs, OR);
  425. break;
  426. case iXOR: rhs = boolCondExp (lhs, rhs, XOR);
  427. break;
  428. }
  429. newAsgnHlIcode (pIcode, lhs, rhs);
  430. invalidateIcode (pIcode + 1);
  431. idx = 0;
  432. }
  433. break;
  434. } /* eos */
  435. /* Check long conditional (i.e. 2 CMPs and 3 branches */
  436. else if ((pIcode->ic.ll.opcode == iCMP) &&
  437. (isLong23 (idx, pIcode->inBB, pProc->Icode.GetFirstIcode(),
  438. &off, &arc)))
  439. {
  440. if (checkLongRegEq (pLocId->id.longId, pIcode, i, idx, pProc,
  441. &rhs, &lhs, off) == TRUE)
  442. longJCond23 (rhs, lhs, pIcode, &idx, pProc, arc, off);
  443. }
  444. /* Check for long conditional equality or inequality. This requires
  445. * 2 CMPs and 2 branches */
  446. else if ((pIcode->ic.ll.opcode == iCMP) &&
  447. (isLong22 (pIcode, pEnd, &off)))
  448. {
  449. if (checkLongRegEq (pLocId->id.longId, pIcode, i, idx, pProc,
  450. &rhs, &lhs, off) == TRUE)
  451. longJCond22 (rhs, lhs, pIcode, &idx);
  452. }
  453. /* Check for OR regH, regL
  454. * JX lab
  455. * => HLI_JCOND (regH:regL X 0) lab
  456. * This is better code than HLI_JCOND (HI(regH:regL) | LO(regH:regL)) */
  457. else if ((pIcode->ic.ll.opcode == iOR) && ((pIcode+1) < pEnd) &&
  458. (isJCond ((pIcode+1)->ic.ll.opcode)))
  459. {
  460. if ((pIcode->ic.ll.dst.regi == pLocId->id.longId.h) &&
  461. (pIcode->ic.ll.src.regi == pLocId->id.longId.l))
  462. {
  463. lhs = idCondExpLongIdx (i);
  464. rhs = idCondExpKte (0, 4); /* long 0 */
  465. lhs = boolCondExp (lhs, rhs,
  466. condOpJCond[(pIcode+1)->ic.ll.opcode - iJB]);
  467. newJCondHlIcode (pIcode+1, lhs);
  468. copyDU (pIcode+1, pIcode, E_USE, E_USE);
  469. invalidateIcode (pIcode);
  470. }
  471. }
  472. } /* end for */
  473. } /* end for */
  474. }
  475. static void propLongGlb (Int i, ID *pLocId, PPROC pProc)
  476. /* Propagates the long global address across all LOW_LEVEL icodes.
  477. * Transforms some LOW_LEVEL icodes into HIGH_LEVEL */
  478. {
  479. }
  480. void propLong (PPROC pProc)
  481. /* Propagated identifier information, thus converting some LOW_LEVEL icodes
  482. * into HIGH_LEVEL icodes. */
  483. { Int i;
  484. ID *pLocId; /* Pointer to current local identifier */
  485. for (i = 0; i < pProc->localId.csym; i++)
  486. {
  487. pLocId = &pProc->localId.id[i];
  488. if ((pLocId->type==TYPE_LONG_SIGN) || (pLocId->type==TYPE_LONG_UNSIGN))
  489. {
  490. switch (pLocId->loc) {
  491. case STK_FRAME: propLongStk (i, pLocId, pProc);
  492. break;
  493. case REG_FRAME: propLongReg (i, pLocId, pProc);
  494. break;
  495. case GLB_FRAME: propLongGlb (i, pLocId, pProc);
  496. break;
  497. }
  498. }
  499. }
  500. }