开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
dyncode_arm.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：16k
源码类别：

Windows CE

开发平台：

C/C++

dyncode_arm.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: dyncode_arm.c 585 2006-01-16 09:48:55Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  25. #include "dyncode.h"
  27. #if defined(ARM) && defined(CONFIG_DYNCODE)
  29. void InstInit()
  30. {
  31. context* c = Context();
  32. c->NextCond = AL;
  33. c->NextSet = 0;
  34. c->NextByte = 0;
  35. c->NextHalf = 0;
  36. c->NextSign = 0;
  37. }
  39. void InstPost(dyninst* p)
  40. {
  41. context* c = Context();
  42. InstAdd(p,c);
  44. c->NextCond = AL;
  45. c->NextSet = 0;
  46. c->NextByte = 0;
  47. c->NextHalf = 0;
  48. c->NextSign = 0;
  49. }
  51. void Byte()
  52. {
  53. context* c = Context();
  54. c->NextByte = 1;
  55. c->NextSign = 0;
  56. }
  58. void Half()
  59. {
  60. context* c = Context();
  61. c->NextHalf = 1;
  62. c->NextSign = 0;
  63. }
  65. void SByte()
  66. {
  67. context* c = Context();
  68. c->NextByte = 1;
  69. c->NextSign = 1;
  70. }
  72. void SHalf()
  73. {
  74. context* c = Context();
  75. c->NextHalf = 1;
  76. c->NextSign = 1;
  77. }
  79. void C(int i)
  80. {
  81. context* c = Context();
  82. c->NextCond = i;
  83. }
  85. void S()
  86. {
  87. context* c = Context();
  88. c->NextSet = 1;
  89. }
  91. void IPLD(int* Code, reg* Dest)
  92. {
  93. context* c = Context();
  94. switch (*Code)
  95. {
  96. case PLD: c->NextCond=15; c->NextByte=1; *Code = LDR; *Dest=PC; break;
  97. case PLD_PRE: c->NextCond=15; c->NextByte=1; *Code = LDR_PRE; *Dest=PC; break;
  98. case PLD_POST: c->NextCond=15; c->NextByte=1; *Code = LDR_POST; *Dest=PC; break;
  99. case PLD_PRESUB: c->NextCond=15; c->NextByte=1; *Code = LDR_PRESUB; *Dest=PC; break;
  100. case PLD_POSTSUB: c->NextCond=15; c->NextByte=1; *Code = LDR_POSTSUB; *Dest=PC; break;
  101. }
  102. }
  104. #define MODE(x) ((uint32_t)(x) >> 28)
  105. #define MODEMASK ~0xF0000000
  107. void I3C(int Code, reg Dest, reg Op1, reg Op2,int Const)
  108. {
  109. context* c = Context();
  110. dyninst* p = NULL;
  112. if (MODE(Code) == 8 && Const>=0 && Const<8)
  113. {
  114. p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 12) | ((Op1 & 15) << 16) | ((Op2 & 15) << 0) | (Const << 20),
  115. Dest, Op1, Op2, (c->NextCond != AL)?1:0, 0);
  116. }
  118. InstPost(p);
  119. }
  121. void I3(int Code, reg Dest, reg Op1, reg Op2)
  122. {
  123. context* c = Context();
  124. if (MODE(Code) == 4)
  125. {
  126. dyninst* p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 0) | ((Op1 & 15) << 12) | ((Op2 & 15) << 16),
  127. Dest, Op1, Op2, (c->NextCond != AL)?1:0, 0);
  128. InstPost(p);
  129. }
  130. else
  131. if (MODE(Code) == 7)
  132. {
  133. dyninst* p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 12) | ((Op1 & 15) << 16) | ((Op2 & 15) << 0),
  134. Dest, Op1, Op2, (c->NextCond != AL)?1:0, 0);
  135. InstPost(p);
  136. }
  137. else
  138. I3S(Code,Dest,Op1,Op2,LSL,0);
  139. }
  141. void I3S(int Code, reg Dest, reg Op1, reg Op2, int ShiftType, int Shift)
  142. {
  143. context* c = Context();
  144. dyninst* p = NULL;
  146. if (Shift == 0)
  147. ShiftType = LSL;
  149. if (ShiftType == LSL && Shift < 0)
  150. {
  151. ShiftType = LSR;
  152. Shift = -Shift;
  153. }
  154. if ((ShiftType == LSR || ShiftType == ASR) && Shift < 0)
  155. {
  156. ShiftType = LSL;
  157. Shift = -Shift;
  158. }
  159. if (ShiftType == ROR && Shift < 0)
  160. Shift = Shift & 31;
  162. if (Shift >= 0 && Shift < 32)
  163. {
  164. if (Code >= 0 && Code < 16)
  165. {
  166. if (Code == CMP || Code == TST || Code == CMN || Code == TEQ) 
  167. c->NextSet = 1;
  169. p = InstCreate32((c->NextCond << 28) | (Code << 21) | ((c->NextSet?1:0)<<20) |
  170. ((Op1==NONE?R0:Op1) << 16) | ((Dest==NONE?R0:Dest) << 12) | (Shift << 7) | (ShiftType << 5) | (Op2),
  171. Dest, Op1, Op2, (c->NextCond != AL)?1:0, c->NextSet?1:0);
  172. }
  173. if (Shift == 0)
  174. {
  175. if (Code == MUL && Dest != Op1)
  176. {
  177. p = InstCreate32((c->NextCond << 28) | ((c->NextSet?1:0)<<20) |
  178. (Dest << 16) | (Op2 << 8) | 0x90 | (Op1),
  179. Dest, Op1, Op2, (c->NextCond != AL)?1:0, c->NextSet?1:0);
  180. }
  181. if (Code >= QADD && Code <= QDSUB)
  182. {
  183. p = InstCreate32((c->NextCond << 28) | 
  184. (Dest << 12) | (Op1) | (Op2 << 16) | (0x5 << 4) | (1<<24) | ((Code-QADD)<<21),
  185. Dest, Op1, Op2, (c->NextCond != AL)?1:0, c->NextSet?1:0);
  186. }
  187. }
  189. IPLD(&Code,&Dest);
  191. if (Code == LDR || Code == STR || 
  192. Code == LDR_PRE || Code == STR_PRE || 
  193. Code == LDR_POST|| Code == STR_POST ||
  194. Code == LDR_PRESUB || Code == STR_PRESUB || 
  195. Code == LDR_POSTSUB || Code == STR_POSTSUB)
  196. {
  197. bool_t Pre = (Code != LDR_POST) && (Code != STR_POST) && (Code != LDR_POSTSUB) && (Code != STR_POSTSUB);
  198. bool_t PreWrite = (Code == LDR_PRE) || (Code == STR_PRE) || (Code == LDR_PRESUB) || (Code == STR_PRESUB);
  199. bool_t Load = (Code == LDR) || (Code == LDR_PRE) || (Code == LDR_POST) || (Code == LDR_PRESUB) || (Code == LDR_POSTSUB);
  200. bool_t Unsigned = (Code != LDR_PRESUB) && (Code != STR_PRESUB) && (Code != LDR_POSTSUB) && (Code != STR_POSTSUB);
  202. if (c->NextHalf || c->NextSign)
  203. {
  204. if (Shift==0 && (c->NextHalf || c->NextByte))
  205. p = InstCreate32((c->NextCond << 28) | 
  206. ((Pre?1:0)<<24) | (Unsigned<<23) | 
  207. ((PreWrite?1:0)<<21) | (Load<<20) | (c->NextSign << 6) | (c->NextHalf << 5) |
  208. (Op1 << 16) | (Dest << 12) | (9 << 4) | Op2,
  209. NONE, Op1, Op2, (c->NextCond != AL)?1:0, 0);
  210. }
  211. else
  212. p = InstCreate32((c->NextCond << 28) | (3 << 25) |
  213. ((Pre?1:0)<<24) | (Unsigned<<23) | (c->NextByte<<22) |
  214. ((PreWrite?1:0)<<21) | (Load<<20) |
  215. (Op1 << 16) | (Dest << 12) | (Shift << 7) | (ShiftType << 5) | Op2,
  216. NONE, Op1, Op2, (c->NextCond != AL)?1:0, 0);
  218. if (p)
  219. {
  220. if (Load)
  221. p->WrRegs |= 1 << Dest;
  222. else
  223. p->RdRegs |= 1 << Dest;
  225. if (!Pre || PreWrite)
  226. p->WrRegs |= 1 << Op1;
  227. }
  228. }
  229. }
  230. InstPost(p);
  231. }
  233. void I4(int Code, reg Dest, reg Op1, reg Op2, reg Op3)
  234. {
  235. context* c = Context();
  236. dyninst* p = NULL;
  237. if (Code == MLA)
  238. {
  239. p = InstCreate32((c->NextCond << 28) | (1 << 21) | ((c->NextSet?1:0)<<20) |
  240. (Dest << 16) | (Op3 << 12) | (Op2 << 8) | 0x90 | (Op1),
  241. Dest, Op1, Op2, (c->NextCond != AL)?1:0, c->NextSet?1:0);
  243. if (p) p->RdRegs |= 1 << Op3;
  245. }
  246. InstPost(p);
  247. }
  249. void IMul(reg Dest, reg Op1, int Mul)
  250. {
  251. if (Dest == Op1)
  252. InstPost(NULL); //assert
  254. switch (Mul)
  255. {
  256. case 0: I2C(MOV,Dest,NONE,0); break;
  257. case 1: I3(MOV,Dest,NONE,Op1); break;
  258. case 2: I3S(MOV,Dest,NONE,Op1,LSL,1); break;
  259. case 3: I3S(ADD,Dest,Op1,Op1,LSL,1); break;
  260. case 4: I3S(MOV,Dest,NONE,Op1,LSL,2); break;
  261. case 5: I3S(ADD,Dest,Op1,Op1,LSL,2); break;
  262. case 6: I3S(MOV,Dest,NONE,Op1,LSL,1); I3S(ADD,Dest,Dest,Dest,LSL,1); break; //2*3
  263. case 7: I3S(RSB,Dest,Op1,Op1,LSL,3); break;
  264. case 8: I3S(MOV,Dest,NONE,Op1,LSL,3); break;
  265. case 9: I3S(ADD,Dest,Op1,Op1,LSL,3); break;
  266. case 10: I3S(MOV,Dest,NONE,Op1,LSL,1); I3S(ADD,Dest,Dest,Dest,LSL,2); break; //2*5
  267. case 11: I3S(RSB,Dest,Op1,Op1,LSL,3); I3S(ADD,Dest,Dest,Op1,LSL,2); break;  //7+4
  268. case 12: I3S(ADD,Dest,Op1,Op1,LSL,1); I3S(MOV,Dest,NONE,Dest,LSL,2); break; //3*4
  269. case 13: I3S(ADD,Dest,Op1,Op1,LSL,3); I3S(ADD,Dest,Dest,Op1,LSL,2); break;  //9+4
  270. case 14: I3S(RSB,Dest,Op1,Op1,LSL,3); I3(ADD,Dest,Dest,Dest); break;  //7*2
  271. case 15: I3S(RSB,Dest,Op1,Op1,LSL,4); break;
  272. case 16: I3S(MOV,Dest,NONE,Op1,LSL,4); break;
  273. case 17: I3S(ADD,Dest,Op1,Op1,LSL,4); break;
  274. default: I2C(MOV,Dest,NONE,Mul); I3(MUL,Dest,Op1,Dest); break;
  275. }
  276. }
  278. void IConst(reg Dest, int Const)
  279. {
  280. context* c = Context();
  281. dyninst* p = NULL;
  282. int Shift,Code;
  284. if (Const < 0)
  285. {
  286. Code = MVN;
  287. Const = -Const-1;
  288. }
  289. else
  290. Code = MOV;
  292. Const = (Const << 8) | ((Const >> 24) & 255);
  293. for (Shift=8;Shift<=32;Shift+=2)
  294. {
  295. if (Const & 0xC0)
  296. break;
  297. Const = (Const << 2) | ((Const >> 30) & 3);
  298. }
  299. Shift &= 31;
  300. Const &= 255;
  302. p = InstCreate32((c->NextCond << 28) | (1<<25) | (Code << 21) | ((c->NextSet?1:0)<<20) |
  303. (Dest << 12) | (Shift << 7) | Const,
  304. Dest, NONE, NONE, (c->NextCond != AL)?1:0, c->NextSet?1:0);
  306. InstPost(p);
  307. }
  309. void I2(int Code, reg Dest, reg Op1)
  310. {
  311. context* c = Context();
  312. if (MODE(Code) == 1)
  313. {
  314. dyninst* p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 16) | ((Op1 & 15) << 12),
  315. Dest, Op1, NONE, (c->NextCond != AL)?1:0, 0);
  316. InstPost(p);
  317. }
  318. else
  319. if (MODE(Code) == 6)
  320. {
  321. dyninst* p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 12) | ((Op1 & 15) << 16),
  322. Dest, Op1, NONE, (c->NextCond != AL)?1:0, 0);
  323. InstPost(p);
  324. }
  325. else
  326. I2C(Code,Dest,Op1,0);
  327. }
  329. void I2C(int Code, reg Dest, reg Op1, int Const)
  330. {
  331. int Shift;
  332. context* c = Context();
  333. dyninst* p = NULL;
  335. if (MODE(Code) == 2 && Const>=0 && Const<8)
  336. {
  337. p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 16) | ((Op1 & 15) << 12) | (Const << 0),
  338. Dest, Op1, NONE, (c->NextCond != AL)?1:0, 0);
  339. }
  341. if (MODE(Code) == 9 && Const>=0 && Const<256)
  342. {
  343. p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 12) | ((Op1 & 15) << 16) | ((Const & 15) << 0) | ((Const & 0xF0) << 16),
  344. Dest, Op1, NONE, (c->NextCond != AL)?1:0, 0);
  345. }
  347. if (MODE(Code) == 15)
  348. {
  349. if (Const<0)
  350. {
  351. Code ^= (1<<23);
  352. Const = -Const;
  353. }
  354. if (Code & 256) // dword or qword
  355. {
  356. if (Const & 3)
  357. Const = -1;
  358. else
  359. Const >>= 2;
  360. }
  361. if (Const>=0 && Const<256)
  362. {
  363. p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | ((Dest & 15) << 12) | ((Op1 & 15) << 16) | (Const << 0),
  364. NONE, Op1, NONE, (c->NextCond != AL)?1:0, 0);
  366. if (Code & (1<<20))
  367. p->WrRegs |= 1 << Dest;
  368. else
  369. p->RdRegs |= 1 << Dest;
  371. if (!(Code & (1<<24)) || (Code & (1<<21)))
  372. p->WrRegs |= 1 << Op1;
  373. }
  374. }
  376. if (Code >= 0 && Code < 16)
  377. {
  378. if (Code == MOV && Const < 0)
  379. {
  380. Code = MVN;
  381. Const = -Const-1;
  382. }
  383. else
  384. if (Code == ADD && Const < 0)
  385. {
  386. Code = SUB;
  387. Const = -Const;
  388. }
  389. else
  390. if (Code == SUB && Const < 0)
  391. {
  392. Code = ADD;
  393. Const = -Const;
  394. }
  396. if (Code == CMP || Code == TST || Code == CMN || Code == TEQ) 
  397. c->NextSet = 1;
  399. for (Shift = 0;Shift<32;Shift+=2)
  400. {
  401. if (Const >= 0 && Const <= 255)
  402. break;
  403. Const = (Const << 2) | ((Const >> 30) & 3);
  404. }
  405. if (Const >= 0 && Const <= 255)
  406. p = InstCreate32((c->NextCond << 28) | (1<<25) | (Code << 21) | ((c->NextSet?1:0)<<20) |
  407. ((Op1==NONE?R0:Op1) << 16) | ((Dest==NONE?R0:Dest) << 12) | (Shift << 7) | Const,
  408. Dest, Op1, NONE, (c->NextCond != AL)?1:0, c->NextSet?1:0);
  409. }
  411. IPLD(&Code,&Dest);
  413. if (Code == LDR || Code == STR || 
  414. Code == LDR_PRE || Code == STR_PRE || 
  415. Code == LDR_POST|| Code == STR_POST ||
  416. Code == LDR_PRESUB || Code == STR_PRESUB || 
  417. Code == LDR_POSTSUB || Code == STR_POSTSUB)
  418. {
  419. bool_t Pre = (Code != LDR_POST) && (Code != STR_POST) && (Code != LDR_POSTSUB) && (Code != STR_POSTSUB);
  420. bool_t PreWrite = (Code == LDR_PRE) || (Code == STR_PRE) || (Code == LDR_PRESUB) || (Code == STR_PRESUB);
  421. bool_t Load = (Code == LDR) || (Code == LDR_PRE) || (Code == LDR_POST) || (Code == LDR_PRESUB) || (Code == LDR_POSTSUB);
  422. bool_t Unsigned = (Code != LDR_PRESUB) && (Code != STR_PRESUB) && (Code != LDR_POSTSUB) && (Code != STR_POSTSUB);
  424. if (Const == 0)
  425. {
  426. Pre = 1;
  427. PreWrite = 0;
  428. }
  429. if (Const < 0)
  430. {
  431. Const = -Const;
  432. Unsigned = !Unsigned;
  433. }
  435. if (c->NextHalf || c->NextSign)
  436. {
  437. if (Const >= 0 && Const < 256 && (c->NextHalf || c->NextByte))
  438. p = InstCreate32((c->NextCond << 28) | 
  439. ((Pre?1:0)<<24) | (Unsigned<<23) | (1 << 22) |
  440. ((PreWrite?1:0)<<21) | (Load<<20) | (c->NextSign << 6) | (c->NextHalf << 5) |
  441. (Op1 << 16) | (Dest << 12) | ((Const >> 4) << 8) | (9 << 4) | (Const & 15),
  442. NONE, Op1, NONE, (c->NextCond != AL)?1:0, 0);
  443. }
  444. else
  445. if (Const >= 0 && Const < 4096)
  446. p = InstCreate32((c->NextCond << 28) | (1 << 26) |
  447. ((Pre?1:0)<<24) | (Unsigned<<23) | (c->NextByte<<22) |
  448. ((PreWrite?1:0)<<21) | (Load<<20) |
  449. (Op1 << 16) | (Dest << 12) | Const,
  450. NONE, Op1, NONE, (c->NextCond != AL)?1:0, 0);
  452. if (p)
  453. {
  454. if (Load)
  455. p->WrRegs |= 1 << Dest;
  456. else
  457. p->RdRegs |= 1 << Dest;
  459. if (!Pre || PreWrite)
  460. p->WrRegs |= 1 << Op1;
  461. }
  462. }
  464. InstPost(p);
  465. }
  468. void I1P(int Code, reg Dest, dyninst* Block, int Ofs)
  469. {
  470. context* c = Context();
  471. dyninst* p = NULL;
  473. if (MODE(Code)==15)
  474. {
  475. p = InstCreate32((c->NextCond << 28) | (Code & MODEMASK) | (PC << 16) | ((Dest & 15) << 12),
  476. Dest, PC, NONE, (c->NextCond != AL)?1:0, 0);
  478. if (p)
  479. {
  480. p->Tag = Ofs;
  481. p->ReAlloc = Block;
  482. }
  483. }
  485. if (Code == LDR || Code == STR)
  486. {
  487. int Load = (Code == LDR);
  489. p = InstCreate32((c->NextCond << 28) | (1 << 26) |
  490. (1<<24) | (c->NextByte<<22) | (Load<<20) |
  491. (PC << 16) | (Dest << 12),
  492. Dest, PC, NONE, (c->NextCond != AL)?1:0, 0);
  494. if (p)
  495. {
  496. p->Tag = Ofs;
  497. p->ReAlloc = Block;
  498. }
  499. }
  500. else
  501. if (Code == MOV) // ADD|SUB,Dst,R15,Ofs
  502. {
  503. p = InstCreate32((c->NextCond << 28) |
  504. (1<<25) | (PC << 16) | (Dest << 12),
  505. Dest, PC, NONE, (c->NextCond != AL)?1:0, 0);
  507. if (p)
  508. {
  509. p->Tag = Ofs;
  510. p->ReAlloc = Block;
  511. }
  512. }
  513. InstPost(p);
  514. }
  516. void I0P(int Code, int Cond, dyninst* Target)
  517. {
  518. dyninst* p = NULL;
  519. if (Code == B || Code == BL)
  520. {
  521. p = InstCreate32((Cond << 28) | (5 << 25) | ((Code == BL?1:0)<<24),
  522. PC, NONE, NONE, (Cond != AL)?1:0, 0);
  523. if (p)
  524. {
  525. if (Code == BL)
  526. p->WrRegs |= 1 << LR;
  527. p->ReAlloc = Target;
  528. p->Branch = 1;
  529. }
  530. }
  531. InstPost(p);
  532. }
  534. void Break()
  535. {
  536. context* c = Context();
  537. dyninst* p = InstCreate32((c->NextCond << 28) | (15 << 24),NONE,NONE,NONE,0,0);
  538. if (p)
  539. p->Branch = 1;
  540. InstPost(p);
  541. }
  543. void CodeBegin()
  544. {
  545. int i;
  546. dyninst* p = InstCreate32(0xE92D5FF0,SP,NONE,NONE,0,0);
  547. if (p)
  548. for (i=4;i<16;++i)
  549. p->RdRegs |= 1 << i;
  550. InstPost(p);
  551. }
  553. void CodeEnd()
  554. {
  555. int i;
  556. dyninst* p = InstCreate32(0xE8BD9FF0,SP,NONE,NONE,0,0);
  557. if (p)
  558. for (i=4;i<16;++i)
  559. p->WrRegs |= 1 << i;
  560. InstPost(p);
  561. }
  563. bool_t InstReAlloc(dyninst* p,dyninst* ReAlloc)
  564. {
  565. int Diff = ReAlloc->Address - (p->Address+8);
  566. int* Code = (int*) InstCode(p);
  568. if (((*Code >> 25) & 7) == 6) //wldr,wstr
  569. {
  570. int Ofs = Diff + p->Tag;
  571. int OfsUnsigned = 1;
  572. if (Ofs < 0)
  573. {
  574. Ofs = -Ofs;
  575. OfsUnsigned = 0;
  576. }
  577. if (*Code & 256)
  578. {
  579. if (Ofs & 3)
  580. Ofs = 256;
  581. else
  582. Ofs >>= 2;
  583. }
  584. if (Ofs < 256)
  585. {
  586. *Code &= ~(1<<23);
  587. *Code |= OfsUnsigned<<23;
  588. *Code &= ~255;
  589. *Code |= Ofs;
  590. return 1;
  591. }
  593. DEBUG_MSG1(-1,T("Realloc failed for wldr,wstr %d"),Ofs);
  594. }
  595. else
  596. if (((*Code >> 25) & 7) == 5) //branch
  597. {
  598. *Code &= 0xFF000000;
  599. *Code |= (Diff >> 2) & ~0xFF000000;
  600. return 1;
  601. }
  602. else
  603. if (((*Code >> 25) & 7) == 1) //add dest,pc,#const
  604. {
  605. int Shift;
  606. int Ofs = Diff + p->Tag;
  608. *Code &= ~((15 << 21)|4095);
  610. if (Ofs < 0)
  611. {
  612. Ofs = -Ofs;
  613. *Code |= (SUB << 21);
  614. }
  615. else
  616. *Code |= (ADD << 21);
  618. for (Shift = 0;Shift<32;Shift+=2)
  619. {
  620. if (Ofs >= 0 && Ofs <= 255)
  621. break;
  622. Ofs = (Ofs << 2) | ((Ofs >> 30) & 3);
  623. }
  625. if (Ofs >= 0 && Ofs <= 255)
  626. {
  627. *Code |= (Shift << 7) | Ofs;
  628. return 1;
  629. }
  631. DEBUG_MSG1(-1,T("Realloc failed for add dest,pc,#const %d"),Ofs);
  632. }
  633. else
  634. if (((*Code >> 25) & 7) == 2) //ldr,str
  635. {
  636. int Ofs = Diff + p->Tag;
  637. int OfsUnsigned = 1;
  638. if (Ofs < 0)
  639. {
  640. Ofs = -Ofs;
  641. OfsUnsigned = 0;
  642. }
  643. if (Ofs < 4096)
  644. {
  645. *Code &= ~(1<<23);
  646. *Code |= OfsUnsigned<<23;
  647. *Code &= ~4095;
  648. *Code |= Ofs;
  649. return 1;
  650. }
  652. DEBUG_MSG1(-1,T("Realloc failed for ldr,str %d"),Ofs);
  653. }
  654. return 0;
  655. }
  657. #endif