API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 17th, 2019
95
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.84 KB | None | 0 0
raw download clone embed print report
  1. struct R{
  2. unsigned int opcode: 6;
  3. unsigned int rs: 5;
  4. unsigned int rt: 5;
  5. unsigned int rd: 5;
  6. unsigned int shamt: 5;
  7. unsigned int funct: 6;
  8. };
  9.  
  10. struct R test = {32,0,11,21,19,0}
  11.  
  12. FILE *fp = fopen("./result", "rb");
  13. fwrite(&test,sizeof(test),1,result);
  14.  
  15. 00000000: 00100000 01011000 01110101 00000010
  16.  
  17. 00000000: 00100000 10100000 01110011 00000001
  18.  
  19. struct R{
  20. char opcode[6];
  21. char rs[5];
  22. char rt[5];
  23. char rd[5];
  24. char shamt[5];
  25. char funct[6];
  26. };
  27.  
  28. #include <stdlib.h>
  29. #include <stdio.h>
  30. #include <string.h>
  31. int binpr(unsigned char Byte, FILE *f)
  32. {
  33. char buf[8];
  34. for(int i=0; i<8; i++) buf[i]=(char)(((Byte>>(7-i))&1)+'0');
  35. return (int)+fwrite(buf,1,8,f);
  36. }
  37. struct R{
  38.  
  39. unsigned int opcode: 6;
  40. unsigned int rs: 5;
  41. unsigned int rt: 5;
  42. unsigned int rd: 5;
  43. unsigned int shamt: 5;
  44. unsigned int funct: 6;
  45. };
  46. int main()
  47. {
  48.  
  49. struct R test = {32,0,11,21,19,0};
  50. system(": > result"); //rb requires that the file already exists
  51. FILE *fp = fopen("./result", "rb+");
  52. if(!fp) return perror("fopen"),1;
  53. if(1!=fwrite(&test,sizeof(test),1,fp)) return perror("fwrite"),1;
  54. rewind(fp);
  55. char buf[sizeof(struct R)];
  56. if(1!=fread(&buf,sizeof(buf),1,fp)) return perror("fread"),1;
  57. fputs(" ",stdout); if(0!=memcmp(buf,&test,sizeof test)) abort();
  58. for(size_t i=0; i<sizeof(test); i++) { binpr(*((unsigned char*)&test+i),stdout); fputs(" ",stdout); } puts("");
  59. system("xxd -b result |cut -d: -f2");
  60.  
  61. /*OUTPUT:*/
  62. /*00100000 01011000 01110101 00000010 */
  63. /*00100000 01011000 01110101 00000010 Xu.*/
  64. }
  65.  
  66. #include <stdio.h>
  67. #include <assert.h>
  68.  
  69. static
  70. void format_binary8v(unsigned char x, int n, char buffer[static 9])
  71. {
  72. assert(n > 0 && n <= 8);
  73. int start = 1 << (n - 1);
  74. for (int b = start; b != 0; b /= 2)
  75. {
  76. *buffer++ = ((b & x) != 0) ? '1' : '0';
  77. x &= ~b;
  78. }
  79. *buffer = '';
  80. }
  81.  
  82. static
  83. void format_binary32(unsigned int x, char buffer[static 33])
  84. {
  85. for (unsigned b = 2147483648; b != 0; b /= 2)
  86. {
  87. *buffer++ = ((b & x) != 0) ? '1' : '0';
  88. x &= ~b;
  89. }
  90. *buffer = '';
  91. }
  92.  
  93. struct R
  94. {
  95. unsigned int opcode : 6;
  96. unsigned int rs : 5;
  97. unsigned int rt : 5;
  98. unsigned int rd : 5;
  99. unsigned int shamt : 5;
  100. unsigned int funct : 6;
  101. };
  102.  
  103. static void dump_R(const char *tag, struct R r)
  104. {
  105. union X
  106. {
  107. struct R r;
  108. unsigned int i;
  109. };
  110.  
  111. printf("%s:n", tag);
  112. union X x = { .r = r };
  113. char buffer[33];
  114. format_binary32(x.i, buffer);
  115. printf("Binary: %sn", buffer);
  116. format_binary8v(x.r.opcode, 6, buffer);
  117. printf(" - opcode: %sn", buffer);
  118. format_binary8v(x.r.rs, 5, buffer);
  119. printf(" - rs: %sn", buffer);
  120. format_binary8v(x.r.rt, 5, buffer);
  121. printf(" - rt: %sn", buffer);
  122. format_binary8v(x.r.rd, 5, buffer);
  123. printf(" - rd: %sn", buffer);
  124. format_binary8v(x.r.shamt, 5, buffer);
  125. printf(" - shamt: %sn", buffer);
  126. format_binary8v(x.r.funct, 6, buffer);
  127. printf(" - funct: %sn", buffer);
  128. }
  129.  
  130. int main(void)
  131. {
  132. char filename[] = "filename.bin";
  133. FILE *fp = fopen(filename, "w+b");
  134. if (fp == NULL)
  135. {
  136. fprintf(stderr, "failed to open file '%s' for reading and writingn", filename);
  137. return 1;
  138. }
  139. //struct R test = {32, 0, 11, 21, 19, 0};
  140. struct R test = { 32, 7, 11, 21, 19, 3 };
  141.  
  142. fwrite(&test, sizeof(test), 1, fp);
  143.  
  144. dump_R("test - after write", test);
  145.  
  146. rewind(fp);
  147. fread(&test, sizeof(test), 1, fp);
  148. dump_R("test - after read", test);
  149.  
  150. fclose(fp);
  151. return 0;
  152. }
  153.  
  154. test - after write:
  155. Binary: 00001110011101010101100111100000
  156. - opcode: 100000
  157. - rs: 00111
  158. - rt: 01011
  159. - rd: 10101
  160. - shamt: 10011
  161. - funct: 000011
  162. test - after read:
  163. Binary: 00001110011101010101100111100000
  164. - opcode: 100000
  165. - rs: 00111
  166. - rt: 01011
  167. - rd: 10101
  168. - shamt: 10011
  169. - funct: 000011
  170.  
  171. $ xxd -b filename.bin
  172. 00000000: 11100000 01011001 01110101 00001110 .Yu.
  173. $
  174.  
  175. test - after write:
  176. Binary: 00000010011101010101100000100000
  177. - opcode: 100000
  178. - rs: 00000
  179. - rt: 01011
  180. - rd: 10101
  181. - shamt: 10011
  182. - funct: 000000
  183. test - after read:
  184. Binary: 00000010011101010101100000100000
  185. - opcode: 100000
  186. - rs: 00000
  187. - rt: 01011
  188. - rd: 10101
  189. - shamt: 10011
  190. - funct: 000000
  191.  
  192. 00000000: 00100000 01011000 01110101 00000010 Xu.
  193.  
  194. #include <assert.h>
  195. #include <stdio.h>
  196. #include <stdlib.h>
  197. #include <string.h>
  198.  
  199. struct R
  200. {
  201. unsigned int opcode : 6;
  202. unsigned int rs : 5;
  203. unsigned int rt : 5;
  204. unsigned int rd : 5;
  205. unsigned int shamt : 5;
  206. unsigned int funct : 6;
  207. };
  208.  
  209. static void test_r(const char *tag, struct R r, FILE *fp);
  210. static void run_xxd(const char *file);
  211.  
  212. int main(void)
  213. {
  214. char filename[] = "filename.bin";
  215. FILE *fp = fopen(filename, "w+b");
  216. if (fp == NULL)
  217. {
  218. fprintf(stderr, "failed to open file '%s' for reading and writingn", filename);
  219. return 1;
  220. }
  221.  
  222. struct R r[] =
  223. {
  224. { 32, 0, 11, 21, 19, 0 },
  225. { 32, 7, 11, 21, 19, 3 },
  226. { 6, 21, 10, 14, 10, 8 },
  227. };
  228. enum { NUM_R = sizeof(r) / sizeof(r[0]) };
  229.  
  230. for (int i = 0; i < NUM_R; i++)
  231. {
  232. char name[16];
  233. snprintf(name, sizeof(name), "r%d", i+1);
  234. test_r(name, r[i], fp);
  235. }
  236.  
  237. fclose(fp);
  238.  
  239. run_xxd(filename);
  240.  
  241. return 0;
  242. }
  243.  
  244. static void run_one_xxd(const char *command, const char *filename)
  245. {
  246. char cmd[256];
  247. snprintf(cmd, sizeof(cmd), "%s %s", command, filename);
  248. printf("nCommand: %sn", cmd);
  249. fflush(stdout);
  250. system(cmd);
  251. putchar('n');
  252. }
  253.  
  254. static void run_xxd(const char *filename)
  255. {
  256. run_one_xxd("xxd -c 4 -b ", filename);
  257. run_one_xxd("xxd -c 4 -g 1 -u", filename);
  258. }
  259.  
  260. static void format_binary8v(unsigned char x, int n, char buffer[static 9]);
  261. static void format_binary32(unsigned x, char buffer[static 33]);
  262. static void dump_bitfield(int nbits, unsigned value, const char *name);
  263. static void dump_bytes(const char *tag, struct R r);
  264. static void dump_R(const char *tag, struct R r);
  265.  
  266. static void test_r(const char *tag, struct R r, FILE *fp)
  267. {
  268. char buffer[32];
  269. long offset = sizeof(struct R);
  270. putchar('n');
  271. fwrite(&r, sizeof(r), 1, fp);
  272. snprintf(buffer, sizeof(buffer), "%s - after write", tag);
  273. dump_R(buffer, r);
  274. fseek(fp, -offset, SEEK_CUR);
  275. struct R s;
  276. fread(&s, sizeof(s), 1, fp);
  277. fseek(fp, 0, SEEK_CUR); // Ready for reading or writing!
  278. snprintf(buffer, sizeof(buffer), "%s - after read", tag);
  279. dump_R(buffer, s);
  280. /* Safe regardless of whether struct R uses all bits in its storage unit */
  281. assert(r.opcode == s.opcode);
  282. assert(r.rs == s.rs );
  283. assert(r.rs == s.rs );
  284. assert(r.rs == s.rs );
  285. assert(r.shamt == s.shamt );
  286. assert(r.funct == s.funct );
  287. /* Only safe because struct R uses all bits of its storage unit */
  288. assert(memcmp(&r, &s, sizeof(struct R)) == 0);
  289. }
  290.  
  291. static void dump_R(const char *tag, struct R r)
  292. {
  293. printf("%s:n", tag);
  294. dump_bytes("Binary", r);
  295. dump_bitfield(6, r.opcode, "opcode");
  296. dump_bitfield(5, r.rs, "rs");
  297. dump_bitfield(5, r.rt, "rt");
  298. dump_bitfield(5, r.rd, "rd");
  299. dump_bitfield(5, r.shamt, "shamt");
  300. dump_bitfield(6, r.funct, "funct");
  301. }
  302.  
  303. static void dump_bytes(const char *tag, struct R r)
  304. {
  305. union X
  306. {
  307. struct R r;
  308. unsigned i;
  309. };
  310. union X x = { .r = r };
  311. char buffer[33];
  312. printf("%s: 0x%.8Xn", tag, x.i);
  313. format_binary32(x.i, buffer);
  314. //printf("%s: MSB %s LSBn", tag, buffer);
  315. printf("%s: MSB", tag);
  316. for (int i = 0; i < 4; i++)
  317. printf(" %.8s", &buffer[8 * i]);
  318. puts(" LSB (big-endian)");
  319. printf("%s: LSB", tag);
  320. for (int i = 0; i < 4; i++)
  321. printf(" %.8s", &buffer[8 * (3 - i)]);
  322. puts(" MSB (little-endian)");
  323. }
  324.  
  325. static void dump_bitfield(int nbits, unsigned value, const char *name)
  326. {
  327. assert(nbits > 0 && nbits <= 32);
  328. char vbuffer[33];
  329. char nbuffer[8];
  330. snprintf(nbuffer, sizeof(nbuffer), "%s:", name);
  331. format_binary8v(value, nbits, vbuffer);
  332. printf(" - %-7s %6s (%u)n", nbuffer, vbuffer, value);
  333. }
  334.  
  335. static
  336. void format_binary8v(unsigned char x, int n, char buffer[static 9])
  337. {
  338. assert(n > 0 && n <= 8);
  339. int start = 1 << (n - 1);
  340. for (int b = start; b != 0; b /= 2)
  341. {
  342. *buffer++ = ((b & x) != 0) ? '1' : '0';
  343. x &= ~b;
  344. }
  345. *buffer = '';
  346. }
  347.  
  348. static
  349. void format_binary32(unsigned x, char buffer[static 33])
  350. {
  351. for (unsigned b = 2147483648; b != 0; b /= 2)
  352. {
  353. *buffer++ = ((b & x) != 0) ? '1' : '0';
  354. x &= ~b;
  355. }
  356. *buffer = '';
  357. }
  358.  
  359. r1 - after write:
  360. Binary: 0x02755820
  361. Binary: MSB 00000010 01110101 01011000 00100000 LSB (big-endian)
  362. Binary: LSB 00100000 01011000 01110101 00000010 MSB (little-endian)
  363. - opcode: 100000 (32)
  364. - rs: 00000 (0)
  365. - rt: 01011 (11)
  366. - rd: 10101 (21)
  367. - shamt: 10011 (19)
  368. - funct: 000000 (0)
  369. r1 - after read:
  370. Binary: 0x02755820
  371. Binary: MSB 00000010 01110101 01011000 00100000 LSB (big-endian)
  372. Binary: LSB 00100000 01011000 01110101 00000010 MSB (little-endian)
  373. - opcode: 100000 (32)
  374. - rs: 00000 (0)
  375. - rt: 01011 (11)
  376. - rd: 10101 (21)
  377. - shamt: 10011 (19)
  378. - funct: 000000 (0)
  379.  
  380. r2 - after write:
  381. Binary: 0x0E7559E0
  382. Binary: MSB 00001110 01110101 01011001 11100000 LSB (big-endian)
  383. Binary: LSB 11100000 01011001 01110101 00001110 MSB (little-endian)
  384. - opcode: 100000 (32)
  385. - rs: 00111 (7)
  386. - rt: 01011 (11)
  387. - rd: 10101 (21)
  388. - shamt: 10011 (19)
  389. - funct: 000011 (3)
  390. r2 - after read:
  391. Binary: 0x0E7559E0
  392. Binary: MSB 00001110 01110101 01011001 11100000 LSB (big-endian)
  393. Binary: LSB 11100000 01011001 01110101 00001110 MSB (little-endian)
  394. - opcode: 100000 (32)
  395. - rs: 00111 (7)
  396. - rt: 01011 (11)
  397. - rd: 10101 (21)
  398. - shamt: 10011 (19)
  399. - funct: 000011 (3)
  400.  
  401. r3 - after write:
  402. Binary: 0x214E5546
  403. Binary: MSB 00100001 01001110 01010101 01000110 LSB (big-endian)
  404. Binary: LSB 01000110 01010101 01001110 00100001 MSB (little-endian)
  405. - opcode: 000110 (6)
  406. - rs: 10101 (21)
  407. - rt: 01010 (10)
  408. - rd: 01110 (14)
  409. - shamt: 01010 (10)
  410. - funct: 001000 (8)
  411. r3 - after read:
  412. Binary: 0x214E5546
  413. Binary: MSB 00100001 01001110 01010101 01000110 LSB (big-endian)
  414. Binary: LSB 01000110 01010101 01001110 00100001 MSB (little-endian)
  415. - opcode: 000110 (6)
  416. - rs: 10101 (21)
  417. - rt: 01010 (10)
  418. - rd: 01110 (14)
  419. - shamt: 01010 (10)
  420. - funct: 001000 (8)
  421.  
  422. Command: xxd -c 4 -b filename.bin
  423. 00000000: 00100000 01011000 01110101 00000010 Xu.
  424. 00000004: 11100000 01011001 01110101 00001110 .Yu.
  425. 00000008: 01000110 01010101 01001110 00100001 FUN!
  426.  
  427. Command: xxd -c 4 -g 1 -u filename.bin
  428. 00000000: 20 58 75 02 Xu.
  429. 00000004: E0 59 75 0E .Yu.
  430. 00000008: 46 55 4E 21 FUN!
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!