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

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

Windows CE

开发平台：

C/C++

dyncode_sh3.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_sh3.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(SH3) && defined(CONFIG_DYNCODE)
  29. //format coded in 'code' at 16bit position
  30. //00: rn,imm
  31. //01: rn,label,disp8*2
  32. //02: rn,label,disp8*4
  33. //03: rm,rn
  34. //04: rn,disp4*1
  35. //05: rn,disp4*2
  36. //06: rm,rn,disp4*4
  37. //07: rn
  38. //08: imm
  39. //09: -
  40. //0A: label8
  41. //0B: label12
  42. //0C: rn (branch)
  43. //0D: - (branch)
  45. //read at 20bit / write at 24bit
  46. //01: r1
  47. //02: r2
  48. //04: R0
  49. //08: T
  51. //spec at 28bit
  52. //01: read mac
  53. //02: read pr
  54. //04: write mac
  55. //08: write pr
  57. static INLINE int Format(int i) { return (i >> 16) & 15; }
  58. static INLINE int C(int i) { return i & 0xFFFF; }
  60. void InstInit()
  61. {
  62. }
  64. void InstPost(dyninst* p)
  65. {
  66. context* c = Context();
  67. InstAdd(p,c);
  68. }
  70. void PostAdj(dyninst* p,int Code,reg Rn,reg Rm)
  71. {
  72. if (p)
  73. {
  74. if (Code & (1<<20)) p->RdRegs |= 1 << Rn;
  75. if (Code & (2<<20)) p->RdRegs |= 1 << Rm;
  76. if (Code & (4<<20)) p->RdRegs |= 1 << R0;
  77. if (Code & (1<<28)) p->RdRegs |= 1 << MACL;
  78. if (Code & (2<<28)) p->RdRegs |= 1 << PR;
  79. p->RdFlags = Code & (8<<20) ? 1:0;
  81. if (Code & (1<<24)) p->WrRegs |= 1 << Rn;
  82. if (Code & (2<<24)) p->WrRegs |= 1 << Rm;
  83. if (Code & (4<<24)) p->WrRegs |= 1 << R0;
  84. if (Code & (4<<28)) p->WrRegs |= 1 << MACL;
  85. if (Code & (8<<28)) p->WrRegs |= 1 << PR;
  86. p->WrFlags = Code & (8<<24) ? 1:0;
  87. }
  88. InstPost(p);
  89. }
  91. void IShift(reg Rn, reg Tmp, int Left)
  92. {
  93. switch (Left)
  94. {
  95. default:
  96. if (Tmp != NONE)
  97. {
  98. I1C(MOVI,Tmp,Left);
  99. I2(SHLD,Tmp,Rn);
  100. break;
  101. }
  102. // no break;
  103. case 16+8:
  104. case 16+2:
  105. case 16+1:
  106. case 16:
  107. case 8+2:
  108. case 8+1:
  109. case 8:
  110. case 2+1:
  111. case 2:
  112. case 1:
  113. case 0:
  114. case -16-8:
  115. case -16-2:
  116. case -16-1:
  117. case -16:
  118. case -8-2:
  119. case -8-1:
  120. case -8:
  121. case -2-1:
  122. case -2:
  123. case -1:
  124. while (Left <= -16) { I1(SHLR16,Rn); Left += 16; }
  125. while (Left >= 16) { I1(SHLL16,Rn); Left -= 16; }
  126. while (Left <= -8) { I1(SHLR8,Rn); Left += 8; }
  127. while (Left >= 8) { I1(SHLL8,Rn); Left -= 8; }
  128. while (Left <= -2) { I1(SHLR2,Rn); Left += 2; }
  129. while (Left >= 2) { I1(SHLL2,Rn); Left -= 2; }
  130. while (Left <= -1) { I1(SHLR,Rn); Left += 1; }
  131. while (Left >= 1) { I1(SHLL,Rn); Left -= 1; }
  132. break;
  133. }
  134. }
  136. void I0C(int Code, int Const)
  137. {
  138. dyninst* p = NULL;
  139. if (Format(Code)==8 && Const >= -128 && Const <= 127)
  140. p = InstCreate16(C(Code) | (Const & 255),NONE,NONE,NONE,0,0);
  141. if (Format(Code)==9 && Const == 0)
  142. p = InstCreate16(C(Code),NONE,NONE,NONE,0,0);
  143. if (Format(Code)==13 && Const == 0)
  144. {
  145. p = InstCreate16(C(Code),NONE,NONE,NONE,0,0);
  146. if (p)
  147. p->Branch = 1;
  148. }
  149. PostAdj(p,Code,NONE,NONE);
  150. }
  152. void I0(int Code)
  153. {
  154. I0C(Code,0);
  155. }
  157. void I1C(int Code, reg Rn, int Const)
  158. {
  159. dyninst* p = NULL;
  160. if (Format(Code)==0 && Const >= -128 && Const <= 127)
  161. p = InstCreate16(C(Code) | (Rn << 8) | (Const & 255),NONE,NONE,NONE,0,0);
  162. if (Format(Code)==4 && Const >= -8 && Const <= 7)
  163. p = InstCreate16(C(Code) | (Rn << 4) | (Const & 15),NONE,NONE,NONE,0,0);
  164. if (Format(Code)==5 && !(Const & 1) && Const >= -16 && Const <= 14)
  165. p = InstCreate16(C(Code) | (Rn << 4) | ((Const >> 1) & 15),NONE,NONE,NONE,0,0);
  166. if (Format(Code)==7 && Const == 0)
  167. p = InstCreate16(C(Code) | (Rn << 8),NONE,NONE,NONE,0,0);
  168. if (Format(Code)==12 && Const == 0)
  169. {
  170. p = InstCreate16(C(Code) | (Rn << 8),NONE,NONE,NONE,0,0);
  171. if (p)
  172. p->Branch = 1;
  173. }
  174. PostAdj(p,Code,Rn,NONE);
  175. }
  177. void I1(int Code, reg Rn)
  178. {
  179. I1C(Code,Rn,0);
  180. }
  182. void I2C(int Code, reg Rm, reg Rn, int Const)
  183. {
  184. dyninst* p = NULL;
  185. if (Format(Code)==3 && Const == 0)
  186. p = InstCreate16(C(Code) | (Rn << 8) | (Rm << 4),NONE,NONE,NONE,0,0);
  187. if (Format(Code)==6 && !(Const & 3) && Const >= -32 && Const <= 28)
  188. p = InstCreate16(C(Code) | (Rn << 8) | (Rm << 4) | ((Const >> 2) & 15),NONE,NONE,NONE,0,0);
  189. PostAdj(p,Code,Rm,Rn);
  190. }
  192. void I2(int Code, reg Rm, reg Rn)
  193. {
  194. I2C(Code,Rm,Rn,0);
  195. }
  197. dyninst* ICode(dyninst* Block, int Ofs)
  198. {
  199. dyninst* p = InstCreate32(Ofs,NONE,NONE,NONE,0,0);
  200. if (p)
  201. {
  202. p->Tag = -1;
  203. p->ReAlloc = Block;
  204. p->Branch = 1;
  205. }
  206. return p;
  207. }
  209. void I1P(int Code, reg Rn, dyninst* Block, int Ofs)
  210. {
  211. dyninst* p = NULL;
  212. if (Format(Code)==1 && !(Ofs & 1) && Ofs >= -128*2 && Ofs <= 127*2)
  213. {
  214. p = InstCreate16(C(Code) | (Rn << 8) | ((Ofs >> 1) & 255),Rn,NONE,NONE,0,0);
  215. if (p)
  216. {
  217. p->Tag = Format(Code);
  218. p->ReAlloc = Block;
  219. p->Branch = 1;
  220. }
  221. }
  222. if (Format(Code)==2 && !(Ofs & 3) && Ofs >= -128*4 && Ofs <= 127*4)
  223. {
  224. p = InstCreate16(C(Code) | (Rn << 8) | ((Ofs >> 2) & 255),Rn,NONE,NONE,0,0);
  225. if (p)
  226. {
  227. p->Tag = Format(Code);
  228. p->ReAlloc = Block;
  229. p->Branch = 1;
  230. }
  231. }
  232. PostAdj(p,Code,Rn,NONE);
  233. }
  235. void I0P(int Code, dyninst* Block)
  236. {
  237. dyninst* p = NULL;
  238. if (Format(Code)==10 || Format(Code)==11)
  239. {
  240. p = InstCreate16(C(Code),NONE,NONE,NONE,0,0);
  241. if (p)
  242. {
  243. p->Tag = Format(Code);
  244. p->ReAlloc = Block;
  245. p->Branch = 1;
  246. }
  247. }
  248. PostAdj(p,Code,NONE,NONE);
  249. }
  251. bool_t InstReAlloc(dyninst* p,dyninst* ReAlloc)
  252. {
  253. int Diff = ReAlloc->Address - (p->Address+4);
  254. uint16_t* Code = (uint16_t*) InstCode(p);
  256. Diff >>= 1;
  258. assert(p->Tag == 10 || p->Tag == 1 || p->Tag == 2 || p->Tag == 11 || p->Tag == -1);
  260. if (p->Tag == -1) // 32bit code address
  261. {
  262. *(uint32_t*)Code += (uint32_t)ReAlloc->Address;
  263. return 1;
  264. }
  265. else
  266. if (p->Tag == 10 || p->Tag == 1 || p->Tag == 2) //8bit
  267. {
  268. if (p->Tag == 2)
  269. {
  270. assert(((int)ReAlloc->Address & 3)==0);
  271. Diff = ((int)ReAlloc->Address >> 2) - (((int)p->Address+4) >> 2);
  272. }
  273. Diff += *(int8_t*)Code;
  274. assert(Diff <= 127 && Diff >= -128);
  275. if (Diff > 127 || Diff < -128)
  276. return 0;
  277. *Code &= 0xFF00;
  278. *Code |= (uint16_t)(Diff & 0xFF);
  279. return 1;
  280. }
  281. else
  282. if (p->Tag == 11) //12bit
  283. {
  284. assert(Diff <= 2047 && Diff >= -2048);
  285. if (Diff > 2047 || Diff < -2048)
  286. return 0;
  287. *Code &= 0xF000;
  288. *Code |= (uint16_t)(Diff & 0xFFF);
  289. return 1;
  290. }
  291. return 0;
  292. }
  294. void CodeBegin(int Save,int Local)
  295. {
  296. int i;
  297. assert(Save <= 7);
  298. for (i=0;i<Save;++i)
  299. I2(MOVL_STSUB,(reg)(R8+i),SP);
  300. if (Local)
  301. I1C(ADDI,SP,-Local);
  302. }
  304. void CodeEnd(int Save,int Local)
  305. {
  306. int i;
  307. assert(Save <= 7);
  308. if (Local)
  309. I1C(ADDI,SP,Local);
  310. for (i=Save-1;i>=0;--i)
  311. I2(MOVL_LDADD,SP,(reg)(R8+i));
  312. DS(); I0(RTS);
  313. }
  315. void NOP()
  316. {
  317. dyninst* p = InstCreate16(0x0009,NONE,NONE,NONE,0,0);
  318. if (p)
  319. p->Branch = 1;
  320. InstPost(p);
  321. }
  323. void Break()
  324. {
  325. dyninst* p = InstCreate16(0xC300,NONE,NONE,NONE,0,0);
  326. if (p)
  327. p->Branch = 1;
  328. InstPost(p);
  329. }
  331. #endif