API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 24th, 2017
59
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.17 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdint.h>
  4. #include <string.h>
  5. #include <math.h>
  6.  
  7. // Disciplina: Arquitetura de Computadores
  8. // Aluno: Rafael Barbosa Conceição
  9. // Matrícula: 201420014973
  10.  
  11. const char* parametro(int num){
  12. switch(num){
  13. case 0: return "r0"; break;
  14. case 1: return "r1"; break;
  15. case 2: return "r2"; break;
  16. case 3: return "r3"; break;
  17. case 4: return "r4"; break;
  18. case 5: return "r5"; break;
  19. case 6: return "r6"; break;
  20. case 7: return "r7"; break;
  21. case 8: return "r8"; break;
  22. case 9: return "r9"; break;
  23. case 10: return "r10"; break;
  24. case 11: return "r11"; break;
  25. case 12: return "r12"; break;
  26. case 13: return "r13"; break;
  27. case 14: return "r14"; break;
  28. case 15: return "r15"; break;
  29. case 16: return "r16"; break;
  30. case 17: return "r17"; break;
  31. case 18: return "r18"; break;
  32. case 19: return "r19"; break;
  33. case 20: return "r20"; break;
  34. case 21: return "r21"; break;
  35. case 22: return "r22"; break;
  36. case 23: return "r23"; break;
  37. case 24: return "r24"; break;
  38. case 25: return "r25"; break;
  39. case 26: return "r26"; break;
  40. case 27: return "r27"; break;
  41. case 28: return "r28"; break;
  42. case 29: return "r29"; break;
  43. case 30: return "r30"; break;
  44. case 31: return "r31"; break;
  45. case 32: return "pc"; break;
  46. case 33: return "ir"; break;
  47. case 34: return "er"; break;
  48. case 35: return "fr"; break;
  49. case 36: return "cr"; break;
  50. case 37: return "ipc"; break;
  51. }
  52. }
  53.  
  54. const char* valor(int num){
  55. switch(num){
  56. case 0: return "R0"; break;
  57. case 1: return "R1"; break;
  58. case 2: return "R2"; break;
  59. case 3: return "R3"; break;
  60. case 4: return "R4"; break;
  61. case 5: return "R5"; break;
  62. case 6: return "R6"; break;
  63. case 7: return "R7"; break;
  64. case 8: return "R8"; break;
  65. case 9: return "R9"; break;
  66. case 10: return "R10"; break;
  67. case 11: return "R11"; break;
  68. case 12: return "R12"; break;
  69. case 13: return "R13"; break;
  70. case 14: return "R14"; break;
  71. case 15: return "R15"; break;
  72. case 16: return "R16"; break;
  73. case 17: return "R17"; break;
  74. case 18: return "R18"; break;
  75. case 19: return "R19"; break;
  76. case 20: return "R20"; break;
  77. case 21: return "R21"; break;
  78. case 22: return "R22"; break;
  79. case 23: return "R23"; break;
  80. case 24: return "R24"; break;
  81. case 25: return "R25"; break;
  82. case 26: return "R26"; break;
  83. case 27: return "R27"; break;
  84. case 28: return "R28"; break;
  85. case 29: return "R29"; break;
  86. case 30: return "R30"; break;
  87. case 31: return "R31"; break;
  88. case 32: return "PC"; break;
  89. case 33: return "IR"; break;
  90. case 34: return "ER"; break;
  91. case 35: return "FR"; break;
  92. case 36: return "CR"; break;
  93. case 37: return "IPC"; break;
  94. }
  95. }
  96.  
  97. int main(int argc, char* argv[]){
  98. // Variáveis para trabalhar localmente
  99. argv[1] ="poxim2.txt";
  100. argv[2] ="saida.txt";
  101.  
  102. // mostrando informações do programa
  103. printf("#ARGS = %i\n", argc);
  104. printf("PROGRAMA = %s\n", argv[0]);
  105. printf("ARG1 = %s, ARG2 = %s\n", argv[1], argv[2]);
  106.  
  107. // Ponteiros de arquivos
  108. FILE *entrada;
  109. FILE *saida;
  110.  
  111. // Declarando variáveis a ser utilizada
  112. uint64_t multi, aux;
  113. unsigned int *MEM, ch, RY, RX, OP, OPC, IM16, IM26, R[39];
  114. int i, contaLinha = 0, cursor, Z, X, Y, N, IV, FR, INTP = 0, result = 0, EX=0, EY=0, SZ=0, CTRL=0, S, size = 0, counter_ctrl = 0, INTT = 0;
  115.  
  116. // Determinando o valor de R0, que é imutável.
  117. R[0] = 0x00000000;
  118.  
  119. char *terminal;
  120. terminal = malloc(size);
  121. terminal = NULL;
  122.  
  123. entrada = fopen(argv[1], "r");
  124. saida = fopen(argv[2], "w");
  125.  
  126. while((cursor = fgetc(entrada)) != EOF){
  127. if(cursor == '\n'){
  128. MEM = (unsigned int *) realloc(NULL, contaLinha++ * sizeof(unsigned int));
  129. }
  130. }
  131. fclose(entrada);
  132.  
  133. // Carregando a memóriaf
  134. entrada = fopen(argv[1], "r");
  135. for(i = 0; fscanf(entrada, "%x", &ch) != EOF; i++){
  136. MEM[i] = ch;
  137. }
  138. fclose(entrada);
  139.  
  140. R[32] = 0;
  141. R[34] = 0;
  142. R[36] = 0;
  143. R[37] = 0;
  144. FR = 0x0;
  145.  
  146. fprintf(saida, "[START OF SIMULATION]\n");
  147. while (INTP != 1) {
  148. OP = (MEM[R[32]] & 0xFC000000) >> 26;
  149. switch(OP){
  150.  
  151. // 000000 - Operação de adição com registradores
  152. // Instrução ADD
  153. // Tipo U
  154. // R[Z] = R[X] + R[Y]
  155. // Campo relacionado: OV
  156. case 0x00:
  157. X = (MEM[R[32]] & 0x000003E0) >> 5;
  158. Y = (MEM[R[32]] & 0x0000001F);
  159. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  160.  
  161. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  162. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  163. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  164.  
  165. R[Z] = R[X] + R[Y];
  166.  
  167. // VERIFICANDO OVERFLOW
  168. aux = (uint64_t)R[X] + (uint64_t)R[Y];
  169. if(aux > 0xffffffff){
  170. FR = FR | 0x00000010;
  171. R[35] = FR;
  172. }
  173.  
  174. fprintf(saida, "add %s, %s, %s\n[U] FR = 0x%08X, %s = %s + %s = 0x%08X\n", parametro(Z), parametro(X), parametro(Y), R[35], valor(Z), valor(X), valor(Y), R[Z]);
  175. R[32]++;
  176. break;
  177.  
  178. // 000001 - Operação de adição imediata
  179. // Instrução ADDI
  180. // Tipo F
  181. // R[Z] = R[X] + IM16
  182. // Campo relacionado: OV
  183. case 0x01:
  184. X = (MEM[R[32]] & 0x000003E0) >> 5;
  185. Y = (MEM[R[32]] & 0x0000001F);
  186. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  187.  
  188. R[X] = R[Y] + IM16;
  189.  
  190. // VERIFICANDO OVERFLOW
  191. aux = (uint64_t)R[Y] + (uint64_t)IM16;
  192. if(aux > 0xffffffff){
  193. FR = FR | 0x00000010;
  194. R[35] = FR;
  195. }
  196.  
  197. fprintf(saida, "addi %s, %s, %d\n[F] FR = 0x%08X, %s = %s + 0x%04X = 0x%08X\n", parametro(X), parametro(Y), IM16, R[35], valor(X), valor(Y), IM16, R[X]);
  198. R[32]++;
  199. break;
  200.  
  201. // 000010 - Operação de subtração com registradores
  202. // Instrução SUB
  203. // Tipo U
  204. // R[Z] = R[X] - R[Y]
  205. // Campo relacionado: OV
  206. case 0x02:
  207. X = (MEM[R[32]] & 0x000003E0) >> 5;
  208. Y = (MEM[R[32]] & 0x0000001F);
  209. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  210.  
  211. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  212. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  213. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  214.  
  215. R[Z] = R[X] - R[Y];
  216.  
  217. // VERIFICANDO OVERFLOW
  218. aux = (uint64_t)R[X] - (uint64_t)R[Y];
  219. if(aux > 0xffffffff){
  220. FR = FR | 0x00000010;
  221. R[35] = FR;
  222. }
  223.  
  224. fprintf(saida, "sub %s, %s, %s\n[U] FR = 0x%08X, %s = %s - %s = 0x%08X\n", parametro(Z), parametro(X), parametro(Y), R[35], valor(Z), valor(X), valor(Y), R[Z]);
  225. R[32]++;
  226. break;
  227.  
  228. // 000011 - Operação de subtração imediata
  229. // Instrução SUBI
  230. // Tipo F
  231. // R[Z] = R[X] - IM16
  232. // Campo relacionado: OV
  233. case 0x03:
  234. X = (MEM[R[32]] & 0x000003E0) >> 5;
  235. Y = (MEM[R[32]] & 0x0000001F);
  236. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  237.  
  238. R[X] = R[Y] - IM16;
  239.  
  240. // VERIFICANDO OVERFLOW
  241. aux = (uint64_t)R[Y] - (uint64_t)IM16;
  242. if(aux > 0xffffffff){
  243. FR = FR | 0x00000010;
  244. R[35] = FR;
  245. }
  246.  
  247. fprintf(saida, "subi %s, %s, %d\n[F] FR = 0x%08X, %s = %s - 0x%04X = 0x%08X\n", parametro(X), parametro(Y), IM16, R[35], valor(X), valor(Y), IM16, R[X]);
  248. R[32]++;
  249. break;
  250.  
  251. // 000100 - Operação de multiplicação com registradores
  252. // Instrução MUL
  253. // Tipo U
  254. // ER|R[Z] = R[X] x R[Y]
  255. // Campo relacionado: OV
  256. case 0x04:
  257. X = (MEM[R[32]] & 0x000003E0) >> 5;
  258. Y = (MEM[R[32]] & 0x0000001F);
  259. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  260.  
  261. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  262. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  263. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  264.  
  265. RY = R[Y];
  266. RX = R[X];
  267.  
  268. multi = (uint64_t) R[X] * (uint64_t) R[Y];
  269.  
  270. R[34] = multi >> 32;
  271. R[Z] = multi;
  272. FR = R[34] != 0 ? FR | 0x00000010 : FR & 0xffffffef;
  273. R[35] = FR;
  274.  
  275. fprintf(saida, "mul %s, %s, %s\n[U] FR = 0x%08X, ER = 0x%08X, %s = %s * %s = 0x%08X\n", parametro(Z), parametro(X), parametro(Y), R[35], R[34], valor(Z), valor(X), valor(Y), R[Z]);
  276. R[32]++;
  277. break;
  278.  
  279. // 000101 - Operação de multiplicação imediata
  280. // Instrução MULI
  281. // Tipo U
  282. // ER|R[Z] = R[X] - IM16
  283. // Campo relacionado: OV
  284. case 0x05:
  285. multi = 0;
  286.  
  287. X = (MEM[R[32]] & 0x000003E0) >> 5;
  288. Y = (MEM[R[32]] & 0x0000001F);
  289. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  290. RY = R[Y];
  291.  
  292. multi = (uint64_t) RY * (uint64_t) IM16;
  293.  
  294. R[34] = multi >> 32;
  295. R[X] = multi;
  296. FR = R[34] != 0 ? FR | 0x00000010 : FR & 0xffffffef;
  297. R[35] = FR;
  298.  
  299. fprintf(saida, "muli %s, %s, %d\n[F] FR = 0x%08X, ER = 0x%08X, %s = %s * 0x%04X = 0x%08X\n", parametro(X), parametro(Y), IM16, R[35], R[34], valor(X), valor(Y), IM16, R[X]);
  300. R[32]++;
  301. break;
  302.  
  303. //000110 - Operação de divisão com registradores
  304. // Instrução DIV
  305. // Tipo U
  306. // ER = R[X] mod R[Y], R[Z] = R[X] / R[Y]
  307. // Campo relacionado: OV e ZD
  308. case 0x06:
  309. X = (MEM[R[32]] & 0x000003E0) >> 5;
  310. Y = (MEM[R[32]] & 0x0000001F);
  311. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  312.  
  313. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  314. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  315. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  316.  
  317. if(R[Y] == 0){
  318. FR = FR | 0x8;
  319. R[35] = FR;
  320. int aux = FR & 0x40;
  321. // verifica se IE == 1
  322. if(aux){
  323. FR = FR | 0x8; // ZD = 1
  324. R[35] = FR;
  325. R[36] = 1;
  326. INTT = 1;
  327. }
  328. } else {
  329. FR = FR | 0x7; // ZD = 0 //Zerando ZD
  330. R[35] = FR;
  331. R[Z] = R[X] / R[Y];
  332. R[34] = R[X] % R[Y];
  333. }
  334.  
  335. fprintf(saida, "div %s, %s, %s\n[U] FR = 0x%08X, ER = 0x%08X, %s = %s / %s = 0x%08X\n", parametro(Z), parametro(X), parametro(Y), R[35], R[34], valor(Z), valor(X), valor(Y), R[Z]);
  336. R[32]++;
  337. break;
  338.  
  339. //000111 - Operação de divisão imediata
  340. // Instrução DIVI
  341. // Tipo F
  342. // ER = R[Y] mod IM16, R[X] = R[Y] / IM16
  343. // Campo relacionado: OV e ZD
  344. case 0x07:
  345. X = (MEM[R[32]] & 0x000003E0) >> 5;
  346. Y = (MEM[R[32]] & 0x0000001F);
  347. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  348.  
  349. if(IM16 == 0){
  350. FR = FR | 0x8;
  351. R[35] = FR;
  352. int aux = FR & 0x40;
  353. // verifica se IE == 1
  354. if(aux){
  355. FR = FR | 0x8; // ZD = 1
  356. R[35] = FR;
  357. R[36] = 1;
  358. INTT = 1;
  359. }
  360. } else {
  361. FR = FR | 0x7; // ZD = 0 //Zerando ZD
  362. R[35] = FR;
  363. R[X] = R[Y] / IM16;
  364. R[34] = R[Y] % IM16;
  365. }
  366.  
  367. fprintf(saida, "divi %s, %s, %d\n[F] FR = 0x%08X, ER = 0x%08X, %s = %s / 0x%04X = 0x%08X\n", parametro(X), parametro(Y), IM16, R[35], R[34], valor(X), valor(Y), IM16, R[X]);
  368. R[32]++;
  369. break;
  370.  
  371. //001000 - Operação de comparação com registradores
  372. // Instrução CMP
  373. // Tipo U
  374. // EQ = (R[x] == R[y])
  375. // LT = (R[x] < R[y])
  376. // GT = (R[x] > R[y])
  377. case 0x08:
  378. X = (MEM[R[32]] & 0x000003E0) >> 5;
  379. Y = (MEM[R[32]] & 0x0000001F);
  380.  
  381. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  382. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  383.  
  384. RX = R[X];
  385. RY = R[Y];
  386.  
  387. FR = (FR & 0x18);
  388. R[35] = FR;
  389.  
  390. if(RX == RY){
  391. FR = FR | 0x01;
  392. R[35] = FR;
  393. }else if(RX < RY){
  394. FR = FR | 0x02;
  395. R[35] = FR;
  396. }else if(RX > RY){
  397. FR = FR | 0x04;
  398. R[35] = FR;
  399. }else{
  400. FR = 0x00;
  401. R[35] = FR;
  402. }
  403.  
  404. fprintf(saida, "cmp %s, %s\n[U] FR = 0x%08X\n", parametro(X), parametro(Y), R[35]);
  405. R[32]++;
  406. break;
  407.  
  408. //001001 - Operação de comparação imediata
  409. // Instrução CMPI
  410. // Tipo F
  411. // EQ = (R[x] == IM16)
  412. // LT = (R[x] < IM16)
  413. // GT = (R[x] > IM16)
  414. case 0x09:
  415. X = (MEM[R[32]] & 0x000003E0) >> 5;
  416. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  417.  
  418. FR = (FR & 0x18);
  419. R[35] = FR;
  420. if(R[X] == IM16){
  421. FR = FR | 0x01;
  422. R[35] = FR;
  423. }else if(R[X] < IM16){
  424. FR = FR | 0x02;
  425. R[35] = FR;
  426. }else if(R[X] > IM16){
  427. FR = FR | 0x04;
  428. R[35] = FR;
  429. }
  430.  
  431. fprintf(saida, "cmpi %s, %d\n[F] FR = 0x%08X\n", parametro(X), IM16, R[35]);
  432. R[32]++;
  433. break;
  434.  
  435. // 001010 - Operação de deslocamento para esquerda
  436. // Instrução SHL
  437. // Tipo U
  438. // ER | R[Z] = ER | R[X] << (y + 1) = ER | R[x] × 2^(y+1)
  439. case 0x0A:
  440. X = (MEM[R[32]] & 0x000003E0) >> 5;
  441. Y = (MEM[R[32]] & 0x0000001F);
  442. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  443.  
  444. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  445. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  446. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  447.  
  448. R[34] = (MEM[R[32]] & 0x00038000) >> 15;
  449. Y = ( R[34] << 5 ) | Y;
  450.  
  451. uint64_t auxiliar = (uint64_t) R[X] << (Y+1);
  452. R[34] = auxiliar >> 32;
  453. R[Z] = (auxiliar << 32) >> 32;
  454.  
  455. fprintf(saida, "shl %s, %s, %d\n[U] ER = 0x%08X, %s = %s << %d = 0x%08X\n", parametro(Z), parametro(X), Y, R[34], valor(Z), valor(X), (Y + 1), R[Z]);
  456. R[32]++;
  457. break;
  458.  
  459. // 001011 - Operação de deslocamento para direita
  460. // Instrução SHR
  461. // Tipo U
  462. // ER | R[Z] = ER | R[X] >> (y + 1) = ER | R[x] / 2^^(y+1)
  463. case 0x0B:
  464. X = (MEM[R[32]] & 0x000003E0) >> 5;
  465. Y = (MEM[R[32]] & 0x0000001F);
  466. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  467.  
  468. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  469. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  470. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  471.  
  472. R[Z] = R[X] >> (Y + 1);
  473. result = R[34] << (32 - (Y + 1));
  474. R[Z] = (R[Z] | result);
  475. R[34] = R[34] >> (32 - (Y + 1));
  476.  
  477. fprintf(saida, "shr %s, %s, %d\n[U] ER = 0x%08X, %s = %s >> %d = 0x%08X\n", parametro(Z), parametro(X), Y , R[34], valor(Z), valor(X), (Y+1), R[Z]);
  478. R[32]++;
  479. break;
  480.  
  481. // 001100 - Operação de AND
  482. // Instrução AND
  483. // Tipo U
  484. // R[Z] = R[X] ^ R[Y]
  485. case 0x0C:
  486. X = (MEM[R[32]] & 0x000003E0) >> 5;
  487. Y = (MEM[R[32]] & 0x0000001F);
  488. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  489.  
  490. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  491. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  492. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  493.  
  494. R[Z] = (R[X] & R[Y]);
  495.  
  496. fprintf(saida, "and %s, %s, %s\n[U] %s = %s & %s = 0x%08X\n", parametro(Z), parametro(X), parametro(Y), valor(Z), valor(X), valor(Y), R[Z]);
  497. R[32]++;
  498. break;
  499.  
  500. // 001101 - Operação de AND imediato
  501. // Instrução ANDI
  502. // Tipo F
  503. // R[X] = R[Y] ^ IM16
  504. case 0x0D:
  505. X = (MEM[R[32]] & 0x000003E0) >> 5;
  506. Y = (MEM[R[32]] & 0x0000001F);
  507. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  508. R[X] = R[Y] & IM16;
  509.  
  510. fprintf(saida, "andi %s, %s, %d\n[F] %s = %s & 0x%04X = 0x%08X\n", parametro(X), parametro(Y), IM16, valor(X), valor(Y), IM16, R[X]);
  511. R[32]++;
  512. break;
  513.  
  514. // 001110 - Operação de NOT
  515. // Instrução NOT
  516. // Tipo U
  517. // R[X] = ~R[Y]
  518. case 0x0E:
  519. X = (MEM[R[32]] & 0x000003E0) >> 5;
  520. Y = (MEM[R[32]] & 0x0000001F);
  521.  
  522. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  523. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  524.  
  525. R[X] = ~(R[Y]);
  526.  
  527. fprintf(saida, "not %s, %s\n[F] %s = ~%s = 0x%08X\n", parametro(X), parametro(Y), valor(X), valor(Y), R[X]);
  528. R[32]++;
  529. break;
  530.  
  531. // 001111 - Operação de NOT imediato
  532. // Instrução NOTI
  533. // Tipo F
  534. // R[X] = ~IM16
  535. case 0x0F:
  536. X = (MEM[R[32]] & 0x000003E0) >> 5;
  537. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  538. R[X] = ~(IM16);
  539.  
  540. fprintf(saida, "noti %s, %d\n[F] %s = ~0x%04X = 0x%08X\n", parametro(X), IM16, valor(X), IM16, R[X]);
  541. R[32]++;
  542. break;
  543.  
  544. // 010000 - Operação de OR
  545. // Instrução OR
  546. // Tipo U
  547. // R[Z] = R[X] v R[Y]
  548. case 0x10:
  549. X = (MEM[R[32]] & 0x000003E0) >> 5;
  550. Y = (MEM[R[32]] & 0x0000001F);
  551. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  552.  
  553. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  554. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  555. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  556.  
  557. R[Z] = R[X] | R[Y];
  558. FR = R[Z];
  559. R[35] = FR;
  560.  
  561. fprintf(saida, "or %s, %s, %s\n[U] %s = %s | %s = 0x%08X\n", parametro(Z), parametro(X), parametro(Y), valor(Z), valor(X), valor(Y), R[Z]);
  562. R[32]++;
  563. break;
  564.  
  565. // 010001 - Operação de OR imediato
  566. // Instrução ORI
  567. // Tipo F
  568. // R[X] = R[Y] v IM16
  569. case 0x11:
  570. X = (MEM[R[32]] & 0x000003E0) >> 5;
  571. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  572. Y = (MEM[R[32]] & 0x0000001F);
  573. R[X] = R[Y] | IM16;
  574.  
  575. fprintf(saida, "ori %s, %s, %d\n[F] %s = %s | 0x%04X = 0x%08X\n", parametro(X), parametro(Y), IM16, valor(X), valor(Y), IM16, R[X]);
  576. R[32]++;
  577. break;
  578.  
  579. // 010010 - Operação de XOR
  580. // Instrução XOR
  581. // Tipo U
  582. // R[Z] = R[X] xor R[Y]
  583. case 0x12:
  584. X = (MEM[R[32]] & 0x000003E0) >> 5;
  585. Y = (MEM[R[32]] & 0x0000001F);
  586. Z = (MEM[R[32]] & 0x00007C00) >> 10;
  587.  
  588. Y = (((MEM[R[32]] & 0x00008000) >> 15) << 5 ) | Y;
  589. X = (((MEM[R[32]] & 0x00010000) >> 16) << 5 ) | X;
  590. Z = (((MEM[R[32]] & 0x00020000) >> 17) << 5 ) | Z;
  591.  
  592. R[Z] = R[X] ^ R[Y];
  593.  
  594. fprintf(saida, "xor %s, %s, %s\n[U] %s = %s ^ %s = 0x%08X\n", parametro(Z), parametro(X), parametro(Y), valor(Z), valor(X), valor(Y), R[Z]);
  595. R[32]++;
  596. break;
  597.  
  598. // 010011 - Operação de XOR imediato
  599. // Instrução XORI
  600. // Tipo F
  601. // R[X] = R[Y] xor IM16
  602. case 0x13:
  603. X = (MEM[R[32]] & 0x000003E0) >> 5;
  604. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  605. Y = (MEM[R[32]] & 0x0000001F);
  606. R[X] = R[Y] ^ IM16;
  607.  
  608. fprintf(saida, "xori %s, %s, %d\n[F] %s = %s ^ 0x%04X = 0x%08X\n", parametro(X), parametro(Y), IM16, valor(X), valor(Y), IM16, R[X]);
  609. R[32]++;
  610. break;
  611.  
  612. // 010100 - Operação de leitura de palavra da memória
  613. // Instrução LDW
  614. // Tipo F
  615. // R[X] = MEM[(R[Y] + IM16) << 2]
  616. case 0x14:
  617. X = (MEM[R[32]] & 0x000003E0) >> 5;
  618. Y = (MEM[R[32]] & 0x0000001F);
  619. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  620.  
  621. R[X] = MEM[(R[Y] + IM16)];
  622.  
  623. fprintf(saida, "ldw %s, %s, 0x%04X\n[F] %s = MEM[(%s + 0x%04X) << 2] = 0x%08X\n", parametro(X), parametro(Y), IM16, valor(X), valor(Y), IM16, R[X]);
  624. R[32]++;
  625. break;
  626.  
  627. // 010101 - Operação de leitura de byte da memória
  628. // Instrução LDB
  629. // Tipo F
  630. // R[X] = MEM[R[Y] + IM16]
  631. case 0x15:
  632. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  633. Y = (MEM[R[32]] & 0x0000001F);
  634. X = (MEM[R[32]] & 0x000003E0) >> 5;
  635.  
  636. if(((R[Y] + IM16) % 4) == 3 ){
  637. R[X] = (MEM[(R[Y] + IM16) / 4] & 0x000000FF);
  638. }
  639.  
  640. if(((R[Y] + IM16) % 4) == 2 ){
  641. R[X] = (MEM[(R[Y] + IM16) / 4] & 0x0000FF00) >> 8;
  642. }
  643.  
  644. if(((R[Y] + IM16) % 4) == 1 ){
  645. R[X] = (MEM[(R[Y] + IM16) / 4] & 0x00FF0000) >> 16;
  646. }
  647.  
  648. if(((R[Y] + IM16) % 4) == 0 ){
  649. R[X] = (MEM[(R[Y] + IM16) / 4] & 0xFF000000) >> 24;
  650. }
  651.  
  652. fprintf(saida, "ldb %s, %s, 0x%04X\n[F] %s = MEM[%s + 0x%04X] = 0x%02X\n", parametro(X), parametro(Y), IM16, valor(X), valor(Y), IM16, R[X]);
  653. R[32]++;
  654. X++;
  655. break;
  656.  
  657. // 010110 - Operação de escrita de palavra da memória
  658. // Instrução STW
  659. // Tipo F
  660. // MEM[(R[Y] + IM16) << 2] = R[Y]
  661. case 0x16:
  662. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  663. X = (MEM[R[32]] & 0x000003E0) >> 5;
  664. Y = (MEM[R[32]] & 0x0000001F);
  665.  
  666. MEM[(R[X] + IM16)] = R[Y];
  667.  
  668. fprintf(saida, "stw %s, 0x%04X, %s\n[F] MEM[(%s + 0x%04X) << 2] = %s = 0x%08X\n", parametro(X), IM16, parametro(Y), valor(X), IM16, valor(Y), R[Y]);
  669. R[32]++;
  670. break;
  671.  
  672. // 010111 - Operação de escrita de byte da memória
  673. // Instrução STB
  674. // Tipo F
  675. // MEM[R[Y] + IM16] = R[Y]
  676. case 0x17:
  677. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  678. X = (MEM[R[32]] & 0x000003E0) >> 5;
  679. Y = (MEM[R[32]] & 0x0000001F);
  680.  
  681. //Tratar apenas os ultimos dois LSB de RY
  682. unsigned LSB = (R[Y] & 0x000000FF);
  683.  
  684. MEM[(R[X] + IM16)] = LSB;
  685.  
  686. fprintf(saida, "stb %s, 0x%04X, %s\n[F] MEM[%s + 0x%04X] = %s = 0x%02X\n", parametro(X), IM16, parametro(Y), valor(X), IM16, valor(Y), LSB);
  687. R[32]++;
  688. break;
  689.  
  690. // 011000 - PUSH
  691. // Tipo U
  692. // Equivalente às instruções stw e subi, empilhando o
  693. // dado R[y] e decrementa o topo da pilha R[x]
  694. case 0x18:
  695. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  696. X = (MEM[R[32]] & 0x000003E0) >> 5;
  697. Y = (MEM[R[32]] & 0x0000001F);
  698.  
  699. // stw
  700. MEM[R[X]] = R[Y];
  701. // subi
  702. R[X] = R[X] - 1;
  703.  
  704. fprintf(saida, "push %s, %s\n[U] MEM[%s--] = %s = 0x%08X\n", parametro(X), parametro(Y), valor(X), valor(Y), R[Y]);
  705. R[32]++;
  706. break;
  707.  
  708. // 011001 - POP
  709. // Tipo U
  710. // Equivalente às instruções ldw e addi, desempilhando
  711. // o dado R[x] e incrementando o topo da pilha R[y]
  712. case 0x19:
  713. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  714. X = (MEM[R[32]] & 0x000003E0) >> 5;
  715. Y = (MEM[R[32]] & 0x0000001F);
  716.  
  717. // addi
  718. R[Y] = R[Y] + 1;
  719. // ldw
  720. R[X] = MEM[R[Y]];
  721.  
  722. fprintf(saida, "pop %s, %s\n[U] %s = MEM[++%s] = 0x%08X\n", parametro(X), parametro(Y), valor(X), valor(Y), R[X]);
  723. R[32]++;
  724. break;
  725.  
  726. // 011010 - Operação de desvio incondicional
  727. // Instrução BUN
  728. // Tipo S
  729. // R[32] = IM16 << 2
  730. case 0x1A:
  731. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  732. R[32] = IM26;
  733.  
  734. fprintf(saida, "bun 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  735. break;
  736.  
  737. // 011011 - Operação de desvio condicional
  738. // Instrução BEQ
  739. // Tipo S
  740. // EQ -> R[32] = IM26 << 2
  741. case 0x1B:
  742. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  743. R[32] = (FR & 0x00000001) == 0x1 ? IM26 : (R[32]+1);
  744.  
  745. fprintf(saida, "beq 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  746. break;
  747.  
  748. // 011100 - Operação de desvio condicional
  749. // Instrução BLT
  750. // Tipo S
  751. // LT -> R[32] = IM26 << 2
  752. case 0x1C:
  753. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  754. R[32] = (FR & 0x00000002) == 0x2 ? IM26 : (R[32]+1);
  755.  
  756. fprintf(saida, "blt 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  757. break;
  758.  
  759. // 011101 - Operação de desvio condicional
  760. // Instrução BGT
  761. // Tipo S
  762. // GT -> R[32] = IM26 << 2
  763. case 0x1D:
  764. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  765. R[32] = (FR & 0x00000004) == 0x4 ? IM26 : (R[32]+1);
  766.  
  767. fprintf(saida, "bgt 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  768. break;
  769.  
  770. // 011110 - Operação de desvio condicional
  771. // Instrução BNE
  772. // Tipo S
  773. // ~EQ -> R[32] = IM26 << 2
  774. case 0x1E:
  775. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  776. R[32] = (FR & 0x00000001) != 0x00000001 ? IM26 : (R[32]+1);
  777.  
  778. fprintf(saida, "bne 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  779. break;
  780.  
  781. // 011111 - Operação de desvio condicional
  782. // Instrução BLE
  783. // Tipo S
  784. // LT v EQ -> R[32] = IM26 << 2
  785. case 0x1F:
  786. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  787. R[32] = (FR & 0x00000001) == 0x1 || FR == 0x2 ? IM26 : (R[32]+1);
  788.  
  789. fprintf(saida, "ble 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  790. break;
  791.  
  792. // 100000 - Operação de desvio condicional
  793. // Instrução BGE
  794. // Tipo S
  795. // GT v EQ -> R[32] = IM26 << 2
  796. case 0x20:
  797. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  798. R[32] = (FR & 0x00000001) == 0x1 || FR == 0x4 ? IM26 : (R[32]+1);
  799.  
  800. fprintf(saida, "bge 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  801. break;
  802.  
  803. // 100001 - Operação de desvio condicional
  804. // Instrução BZD
  805. // Tipo S
  806. // ZD -> R[32] = IM26 << 2
  807. case 0x21:
  808. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  809. R[32] = (FR & 0x00000008) == 0x8 ? IM26 : (R[32]+1);
  810.  
  811. fprintf(saida, "bzd 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  812. break;
  813.  
  814. // 100010 - Operação de desvio condicional
  815. // Instrução BNZ
  816. // Tipo S
  817. // ~ZD -> R[32] = IM26 << 2
  818. case 0x22:
  819. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  820. R[32] = (FR & 0x00000008) != 0x8 ? IM26 : (R[32]+1);
  821.  
  822. fprintf(saida, "bnz 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  823. break;
  824.  
  825. // 100011 - Operação de desvio condicional
  826. // Instrução BIV
  827. // Tipo S
  828. // IV -> R[32] = IM26 << 2
  829. case 0x23:
  830. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  831. R[32] = (FR & 0x00000020) == 0x20 ? IM26 : (R[32]+1);
  832.  
  833. fprintf(saida, "biv 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  834. break;
  835.  
  836. // 100100 - Operação de desvio condicional
  837. // Instrução BNI
  838. // Tipo S
  839. // ~IV -> R[32] = IM26 << 2
  840. case 0x24:
  841. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  842. R[32] = (FR & 0x00000020) != 0x20 ? IM26 : (R[32]+1);
  843.  
  844. fprintf(saida, "biv 0x%08X\n[S] PC = 0x%08X\n", IM26, R[32]*4);
  845. break;
  846.  
  847. // 100001 - CALL
  848. // Tipo F
  849. // R[X] = (R[32] + 4) >> 2, R[32] = (R[Y] + IM16) << 2
  850. case 0x25:
  851. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  852. Y = (MEM[R[32]] & 0x0000001F);
  853. X = (MEM[R[32]] & 0x000003E0) >> 5;
  854.  
  855. R[X] = R[32] + 1;
  856. R[0] = 0;
  857. R[32] = R[Y] + IM16;
  858.  
  859. fprintf(saida, "call %s, %s, 0x%04X\n[F] %s = (PC + 4) >> 2 = 0x%08X, PC = (%s + 0x%04X) << 2 = 0x%08X\n", parametro(X), parametro(Y), IM16, valor(X), R[X], valor(Y), IM16, R[32] << 2);
  860. break;
  861.  
  862. // 100110 - RET
  863. // Tipo F
  864. // R[32] = R[X] << 2
  865. case 0x26:
  866. X = (MEM[R[32]] & 0x000003E0) >> 5;
  867. R[32] = R[X];
  868.  
  869. fprintf(saida, "ret %s\n[F] PC = %s << 2 = 0x%08X\n", parametro(X), valor(X), R[32] << 2);
  870. break;
  871.  
  872. // 100111 - Operação de chamada de rotina de interrupção
  873. // Instrução ISR
  874. // Tipo F
  875. // R[x] = IR[32] >> 2, R[y] = R[36], R[32] = IM16 << 2
  876. case 0x27:
  877. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  878. Y = (MEM[R[32]] & 0x0000001F);
  879. X = (MEM[R[32]] & 0x000003E0) >> 5;
  880.  
  881. R[X] = R[37];
  882. R[Y] = R[36];
  883. R[32] = IM16;
  884.  
  885. fprintf(saida, "isr %s, %s, 0x%04X\n[F] %s = IPC >> 2 = 0x%08X, %s = CR = 0x%08X, PC = 0x%08X\n", parametro(X), parametro(Y), IM16, valor(X), R[37], valor(Y), R[36], R[32]*4);
  886. break;
  887.  
  888. // 101000 - Operação de retorno de rotina de interrupção
  889. // Instrução RETI
  890. // Tipo F
  891. // R[32] = R[x] << 2
  892. case 0x28:
  893. IM16 = (MEM[R[32]] & 0x03FFFC00) >> 10;
  894. Y = (MEM[R[32]] & 0x0000001F);
  895. X = (MEM[R[32]] & 0x000003E0) >> 5;
  896.  
  897. R[32] = R[X];
  898.  
  899. fprintf(saida, "reti %s\n[F] PC = %d << 2 = 0x%08X\n", parametro(X), R[X], IM16);
  900. break;
  901.  
  902. //111111 - Operação de desvio condicional
  903. // Instrução INT
  904. // Tipo S
  905. // Se IM26 = 0, a execução é finalizada
  906. case 0x3F:
  907. IM26 = (MEM[R[32]] & 0x03FFFFFF);
  908. INTP = IM26 == 0 ? 1 : 0;
  909.  
  910. if(INTP == 1){
  911. //N = R[32] = 0;
  912. //R[36] = 0x0;
  913. R[32] = 0x0C;
  914. R[36] = 1;
  915. fprintf(saida, "int %d\n[S] CR = 0x%08X, PC = 0x%08X\n", N, R[36], R[32]*4);
  916.  
  917. if(strcmp(terminal, "") != 0){
  918. fprintf(saida, "[TR[34]MINAL]\n");
  919. fprintf(saida, "%s\n", terminal);
  920. }
  921.  
  922. fprintf(saida, "[END OF SIMULATION]");
  923. }
  924.  
  925. if(IM26 != 0){
  926. R[36] = IM26;
  927. INTT = 1;
  928. R[37] = R[32]+1;
  929. R[32] = 0xC;
  930. fprintf(saida, "int %d\n[S] CR = 0x%08X, PC = 0x%08X\n", IM26, R[36], R[32]);
  931. }
  932. break;
  933. default:
  934. fprintf(saida, "[INVALID INSTRUCTION @ 0x%08X]\n", R[32]*4);
  935. INTT = 1;
  936. IV = 1;
  937. R[36] = R[32];
  938. break;
  939. }
  940.  
  941. if(INTT == 1){
  942. fprintf(saida, "[SOFTWARE INTR[34]RUPTION]\n");
  943. R[32] = 0x3;
  944. INTT=0;
  945. }
  946.  
  947. }
  948.  
  949. // Fechando os arquivos
  950. fclose(entrada);
  951. fclose(saida);
  952. return 0;
  953. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!