proplong.cpp 21 KB

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