PageRenderTime 456ms CodeModel.GetById 2ms RepoModel.GetById 0ms app.codeStats 0ms

/misc/pascal/insn16/popt/pjopt.c

https://github.com/markangelo/PX4NuttX
C | 450 lines | 342 code | 67 blank | 41 comment | 16 complexity | 07c93fc34d1b2e8ceca58ee66cf7ecdf MD5 | raw file
Possible License(s): GPL-2.0, 0BSD
  1. /**********************************************************************
  2. * pjopt.c
  3. * Branch Optimizations
  4. *
  5. * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
  6. * Author: Gregory Nutt <gnutt@nuttx.org>
  7. *
  8. * Redistribution and use in source and binary forms, with or without
  9. * modification, are permitted provided that the following conditions
  10. * are met:
  11. *
  12. * 1. Redistributions of source code must retain the above copyright
  13. * notice, this list of conditions and the following disclaimer.
  14. * 2. Redistributions in binary form must reproduce the above copyright
  15. * notice, this list of conditions and the following disclaimer in
  16. * the documentation and/or other materials provided with the
  17. * distribution.
  18. * 3. Neither the name NuttX nor the names of its contributors may be
  19. * used to endorse or promote products derived from this software
  20. * without specific prior written permission.
  21. *
  22. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25. * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  26. * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27. * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28. * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  29. * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30. * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  32. * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33. * POSSIBILITY OF SUCH DAMAGE.
  34. *
  35. **********************************************************************/
  36. /**********************************************************************
  37. * Included Files
  38. **********************************************************************/
  39. #include <stdint.h>
  40. #include <stdio.h>
  41. #include "keywords.h"
  42. #include "pdefs.h"
  43. #include "pinsn16.h"
  44. #include "popt.h"
  45. #include "polocal.h"
  46. #include "pjopt.h"
  47. /**********************************************************************/
  48. int16_t BranchOptimize (void)
  49. {
  50. int16_t nchanges = 0;
  51. register int16_t i;
  52. TRACE(stderr, "[BranchOptimize]");
  53. /* At least two pcodes are need to perform branch optimizations */
  54. i = 0;
  55. while (i < nops-1)
  56. {
  57. switch (pptr[i]->op)
  58. {
  59. case oNOT :
  60. switch (pptr[i+1]->op)
  61. {
  62. case oJEQUZ :
  63. pptr[i+1]->op = oJNEQZ;
  64. deletePcode(i);
  65. nchanges++;
  66. break;
  67. case oJNEQZ :
  68. pptr[i+1]->op = oJEQUZ;
  69. deletePcode(i);
  70. nchanges++;
  71. break;
  72. default :
  73. i++;
  74. break;
  75. } /* end switch */
  76. break;
  77. case oNEG :
  78. switch (pptr[i+1]->op)
  79. {
  80. case oJLTZ :
  81. pptr[i+1]->op = oJGTZ;
  82. deletePcode(i);
  83. nchanges++;
  84. break;
  85. case oJGTEZ :
  86. pptr[i+1]->op = oJLTEZ;
  87. deletePcode(i);
  88. nchanges++;
  89. break;
  90. case oJGTZ :
  91. pptr[i+1]->op = oJLTZ;
  92. deletePcode(i);
  93. nchanges++;
  94. break;
  95. case oJLTEZ :
  96. pptr[i+1]->op = oJGTEZ;
  97. deletePcode(i);
  98. nchanges++;
  99. break;
  100. default :
  101. i++;
  102. break;
  103. } /* end switch */
  104. break;
  105. case oEQU :
  106. switch (pptr[i+1]->op)
  107. {
  108. case oNOT :
  109. pptr[i]->op = oNEQ;
  110. deletePcode(i+1);
  111. nchanges++;
  112. break;
  113. case oJEQUZ :
  114. pptr[i+1]->op = oJNEQ;
  115. deletePcode(i);
  116. nchanges++;
  117. break;
  118. case oJNEQZ :
  119. pptr[i+1]->op = oJEQU;
  120. deletePcode(i);
  121. nchanges++;
  122. break;
  123. default :
  124. i++;
  125. break;
  126. } /* end switch */
  127. break;
  128. case oNEQ :
  129. switch (pptr[i+1]->op)
  130. {
  131. case oNOT :
  132. pptr[i]->op = oEQU;
  133. deletePcode(i+1);
  134. nchanges++;
  135. break;
  136. case oJEQUZ :
  137. pptr[i+1]->op = oJEQU;
  138. deletePcode(i);
  139. nchanges++;
  140. break;
  141. case oJNEQZ :
  142. pptr[i+1]->op = oJNEQ;
  143. deletePcode(i);
  144. nchanges++;
  145. break;
  146. default :
  147. i++;
  148. break;
  149. } /* end switch */
  150. break;
  151. case oLT :
  152. switch (pptr[i+1]->op)
  153. {
  154. case oNOT :
  155. pptr[i]->op = oGTE;
  156. deletePcode(i+1);
  157. nchanges++;
  158. break;
  159. case oJEQUZ :
  160. pptr[i+1]->op = oJGTE;
  161. deletePcode(i);
  162. nchanges++;
  163. break;
  164. case oJNEQZ :
  165. pptr[i+1]->op = oJLT;
  166. deletePcode(i);
  167. nchanges++;
  168. break;
  169. default :
  170. i++;
  171. break;
  172. } /* end switch */
  173. break;
  174. case oGTE :
  175. switch (pptr[i+1]->op)
  176. {
  177. case oNOT :
  178. pptr[i]->op = oLT;
  179. deletePcode(i+1);
  180. nchanges++;
  181. break;
  182. case oJEQUZ :
  183. pptr[i+1]->op = oJLT;
  184. deletePcode(i);
  185. nchanges++;
  186. break;
  187. case oJNEQZ :
  188. pptr[i+1]->op = oJGTE;
  189. deletePcode(i);
  190. nchanges++;
  191. break;
  192. default :
  193. i++;
  194. break;
  195. } /* end switch */
  196. break;
  197. case oGT :
  198. switch (pptr[i+1]->op)
  199. {
  200. case oNOT :
  201. pptr[i]->op = oLTE;
  202. deletePcode(i+1);
  203. nchanges++;
  204. break;
  205. case oJEQUZ :
  206. pptr[i+1]->op = oJLTE;
  207. deletePcode(i);
  208. nchanges++;
  209. break;
  210. case oJNEQZ :
  211. pptr[i+1]->op = oJGT;
  212. deletePcode(i);
  213. nchanges++;
  214. break;
  215. default :
  216. i++;
  217. break;
  218. } /* end switch */
  219. break;
  220. case oLTE :
  221. switch (pptr[i+1]->op)
  222. {
  223. case oNOT :
  224. pptr[i]->op = oGT;
  225. deletePcode(i+1);
  226. nchanges++;
  227. break;
  228. case oJEQUZ :
  229. pptr[i+1]->op = oJGT;
  230. deletePcode(i);
  231. nchanges++;
  232. break;
  233. case oJNEQZ :
  234. pptr[i+1]->op = oJLTE;
  235. deletePcode(i);
  236. nchanges++;
  237. break;
  238. default :
  239. i++;
  240. break;
  241. } /* end switch */
  242. break;
  243. case oEQUZ :
  244. switch (pptr[i+1]->op)
  245. {
  246. case oNOT :
  247. pptr[i]->op = oNEQZ;
  248. deletePcode(i+1);
  249. nchanges++;
  250. break;
  251. case oJEQUZ :
  252. pptr[i+1]->op = oJNEQZ;
  253. deletePcode(i);
  254. nchanges++;
  255. break;
  256. case oJNEQZ :
  257. pptr[i+1]->op = oJEQUZ;
  258. deletePcode(i);
  259. nchanges++;
  260. break;
  261. default :
  262. i++;
  263. break;
  264. } /* end switch */
  265. break;
  266. case oNEQZ :
  267. switch (pptr[i+1]->op)
  268. {
  269. case oNOT :
  270. pptr[i]->op = oEQUZ;
  271. deletePcode(i+1);
  272. nchanges++;
  273. break;
  274. case oJEQUZ :
  275. case oJNEQZ :
  276. deletePcode(i);
  277. nchanges++;
  278. break;
  279. default :
  280. i++;
  281. break;
  282. } /* end switch */
  283. break;
  284. case oLTZ :
  285. switch (pptr[i+1]->op)
  286. {
  287. case oNOT :
  288. pptr[i]->op = oGTEZ;
  289. deletePcode(i+1);
  290. nchanges++;
  291. break;
  292. case oJEQUZ :
  293. pptr[i+1]->op = oJGTEZ;
  294. deletePcode(i);
  295. nchanges++;
  296. break;
  297. case oJNEQZ :
  298. pptr[i+1]->op = oJLTZ;
  299. deletePcode(i);
  300. nchanges++;
  301. break;
  302. default :
  303. i++;
  304. break;
  305. } /* end switch */
  306. break;
  307. case oGTEZ :
  308. switch (pptr[i+1]->op)
  309. {
  310. case oNOT :
  311. pptr[i]->op = oLTZ;
  312. deletePcode(i+1);
  313. nchanges++;
  314. break;
  315. case oJEQUZ :
  316. pptr[i+1]->op = oJLTZ;
  317. deletePcode(i);
  318. nchanges++;
  319. break;
  320. case oJNEQZ :
  321. pptr[i+1]->op = oJGTEZ;
  322. deletePcode(i);
  323. nchanges++;
  324. break;
  325. default :
  326. i++;
  327. break;
  328. } /* end switch */
  329. break;
  330. case oGTZ :
  331. switch (pptr[i+1]->op)
  332. {
  333. case oNOT :
  334. pptr[i]->op = oLTEZ;
  335. deletePcode(i+1);
  336. nchanges++;
  337. break;
  338. case oJEQUZ :
  339. pptr[i+1]->op = oJLTEZ;
  340. deletePcode(i);
  341. nchanges++;
  342. break;
  343. case oJNEQZ :
  344. pptr[i+1]->op = oJGTZ;
  345. deletePcode(i);
  346. nchanges++;
  347. break;
  348. default :
  349. i++;
  350. break;
  351. } /* end switch */
  352. break;
  353. case oLTEZ :
  354. switch (pptr[i+1]->op)
  355. {
  356. case oNOT :
  357. pptr[i]->op = oGTZ;
  358. deletePcode(i+1);
  359. nchanges++;
  360. break;
  361. case oJEQUZ :
  362. pptr[i+1]->op = oJGTZ;
  363. deletePcode(i);
  364. nchanges++;
  365. break;
  366. case oJNEQZ :
  367. pptr[i+1]->op = oJLTEZ;
  368. deletePcode(i);
  369. nchanges++;
  370. break;
  371. default :
  372. i++;
  373. break;
  374. } /* end switch */
  375. break;
  376. default :
  377. i++;
  378. break;
  379. } /* end switch */
  380. } /* end while */
  381. return (nchanges);
  382. } /* end BranchOptimize */
  383. /**********************************************************************/