API tools faq
paste
Guest User

Corrupted libc.inc

a guest
Jul 18th, 2024
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 27.39 KB | Source Code | 0 0
raw download clone embed print report
  1. /* Created by tools/inliner - DO NOT EDIT. */
  2. void __c(char *src) {
  3.     for (int i = 0; src[i]; i++)
  4.         SOURCE[source_idx++] = src[i];
  5. }
  6. void libc_generate() {
  7.   __c("/*
  8. \n");
  9.   __c(" * shecc - Self-Hosting and Educational C Compiler.
  10. \n");
  11.   __c(" *
  12. \n");
  13.   __c(" * shecc is freely redistributable under the BSD 2 clause license. See the
  14. \n");
  15.   __c(" * file \"LICENSE\" for information on usage and redistribution of this file.
  16. \n");
  17.   __c(" */
  18. \n");
  19.   __c("
  20. \n");
  21.   __c("/* minimal libc implementation */
  22. \n");
  23.   __c("
  24. \n");
  25.   __c("#define NULL 0
  26. \n");
  27.   __c("
  28. \n");
  29.   __c("#define bool _Bool
  30. \n");
  31.   __c("#define true 1
  32. \n");
  33.   __c("#define false 0
  34. \n");
  35.   __c("
  36. \n");
  37.   __c("#if defined(__arm__)
  38. \n");
  39.   __c("#define __syscall_exit 1
  40. \n");
  41.   __c("#define __syscall_read 3
  42. \n");
  43.   __c("#define __syscall_write 4
  44. \n");
  45.   __c("#define __syscall_close 6
  46. \n");
  47.   __c("#define __syscall_open 5
  48. \n");
  49.   __c("#define __syscall_mmap2 192
  50. \n");
  51.   __c("#define __syscall_munmap 91
  52. \n");
  53.   __c("
  54. \n");
  55.   __c("#elif defined(__riscv)
  56. \n");
  57.   __c("#define __syscall_exit 93
  58. \n");
  59.   __c("#define __syscall_read 63
  60. \n");
  61.   __c("#define __syscall_write 64
  62. \n");
  63.   __c("#define __syscall_close 57
  64. \n");
  65.   __c("#define __syscall_open 1024
  66. \n");
  67.   __c("#define __syscall_openat 56
  68. \n");
  69.   __c("#define __syscall_mmap2 222
  70. \n");
  71.   __c("#define __syscall_munmap 215
  72. \n");
  73.   __c("
  74. \n");
  75.   __c("#else /* Only Arm32 and RV32 are supported */
  76. \n");
  77.   __c("#error \"Unsupported architecture\"
  78. \n");
  79.   __c("#endif
  80. \n");
  81.   __c("
  82. \n");
  83.   __c("#define INT_BUF_LEN 16
  84. \n");
  85.   __c("
  86. \n");
  87.   __c("typedef int FILE;
  88. \n");
  89.   __c("
  90. \n");
  91.   __c("void abort();
  92. \n");
  93.   __c("
  94. \n");
  95.   __c("int strlen(char *str)
  96. \n");
  97.   __c("{
  98. \n");
  99.   __c("    int i = 0;
  100. \n");
  101.   __c("    while (str[i])
  102. \n");
  103.   __c("        i++;
  104. \n");
  105.   __c("    return i;
  106. \n");
  107.   __c("}
  108. \n");
  109.   __c("
  110. \n");
  111.   __c("int strcmp(char *s1, char *s2)
  112. \n");
  113.   __c("{
  114. \n");
  115.   __c("    int i = 0;
  116. \n");
  117.   __c("    while (s1[i] && s2[i]) {
  118. \n");
  119.   __c("        if (s1[i] < s2[i])
  120. \n");
  121.   __c("            return -1;
  122. \n");
  123.   __c("        if (s1[i] > s2[i])
  124. \n");
  125.   __c("            return 1;
  126. \n");
  127.   __c("        i++;
  128. \n");
  129.   __c("    }
  130. \n");
  131.   __c("    return s1[i] - s2[i];
  132. \n");
  133.   __c("}
  134. \n");
  135.   __c("
  136. \n");
  137.   __c("int strncmp(char *s1, char *s2, int len)
  138. \n");
  139.   __c("{
  140. \n");
  141.   __c("    int i = 0;
  142. \n");
  143.   __c("    while (i < len) {
  144. \n");
  145.   __c("        if (s1[i] < s2[i])
  146. \n");
  147.   __c("            return -1;
  148. \n");
  149.   __c("        if (s1[i] > s2[i])
  150. \n");
  151.   __c("            return 1;
  152. \n");
  153.   __c("        i++;
  154. \n");
  155.   __c("    }
  156. \n");
  157.   __c("    return 0;
  158. \n");
  159.   __c("}
  160. \n");
  161.   __c("
  162. \n");
  163.   __c("char *strcpy(char *dest, char *src)
  164. \n");
  165.   __c("{
  166. \n");
  167.   __c("    int i = 0;
  168. \n");
  169.   __c("    while (src[i]) {
  170. \n");
  171.   __c("        dest[i] = src[i];
  172. \n");
  173.   __c("        i++;
  174. \n");
  175.   __c("    }
  176. \n");
  177.   __c("    dest[i] = 0;
  178. \n");
  179.   __c("    return dest;
  180. \n");
  181.   __c("}
  182. \n");
  183.   __c("
  184. \n");
  185.   __c("char *strncpy(char *dest, char *src, int len)
  186. \n");
  187.   __c("{
  188. \n");
  189.   __c("    int i = 0;
  190. \n");
  191.   __c("    int beyond = 0;
  192. \n");
  193.   __c("    while (i < len) {
  194. \n");
  195.   __c("        if (beyond == 0) {
  196. \n");
  197.   __c("            dest[i] = src[i];
  198. \n");
  199.   __c("            if (src[i] == 0)
  200. \n");
  201.   __c("                beyond = 1;
  202. \n");
  203.   __c("        } else {
  204. \n");
  205.   __c("            dest[i] = 0;
  206. \n");
  207.   __c("        }
  208. \n");
  209.   __c("        i++;
  210. \n");
  211.   __c("    }
  212. \n");
  213.   __c("    return dest;
  214. \n");
  215.   __c("}
  216. \n");
  217.   __c("
  218. \n");
  219.   __c("char *memcpy(char *dest, char *src, int count)
  220. \n");
  221.   __c("{
  222. \n");
  223.   __c("    while (count > 0) {
  224. \n");
  225.   __c("        count--;
  226. \n");
  227.   __c("        dest[count] = src[count];
  228. \n");
  229.   __c("    }
  230. \n");
  231.   __c("    return dest;
  232. \n");
  233.   __c("}
  234. \n");
  235.   __c("
  236. \n");
  237.   __c("/* set 10 digits (32bit) without div */
  238. \n");
  239.   __c("void __str_base10(char *pb, int val)
  240. \n");
  241.   __c("{
  242. \n");
  243.   __c("    int neg = 0;
  244. \n");
  245.   __c("
  246. \n");
  247.   __c("    if (val == -2147483648) {
  248. \n");
  249.   __c("        strncpy(pb + INT_BUF_LEN - 11, \"-2147483648\", 11);
  250. \n");
  251.   __c("        return;
  252. \n");
  253.   __c("    }
  254. \n");
  255.   __c("    if (val < 0) {
  256. \n");
  257.   __c("        neg = 1;
  258. \n");
  259.   __c("        val = -val;
  260. \n");
  261.   __c("    }
  262. \n");
  263.   __c("
  264. \n");
  265.   __c("    while (val >= 1000000000) {
  266. \n");
  267.   __c("        val -= 1000000000;
  268. \n");
  269.   __c("        pb[INT_BUF_LEN - 10]++;
  270. \n");
  271.   __c("    }
  272. \n");
  273.   __c("    while (val >= 100000000) {
  274. \n");
  275.   __c("        val -= 100000000;
  276. \n");
  277.   __c("        pb[INT_BUF_LEN - 9]++;
  278. \n");
  279.   __c("    }
  280. \n");
  281.   __c("    while (val >= 10000000) {
  282. \n");
  283.   __c("        val -= 10000000;
  284. \n");
  285.   __c("        pb[INT_BUF_LEN - 8]++;
  286. \n");
  287.   __c("    }
  288. \n");
  289.   __c("    while (val >= 1000000) {
  290. \n");
  291.   __c("        val -= 1000000;
  292. \n");
  293.   __c("        pb[INT_BUF_LEN - 7]++;
  294. \n");
  295.   __c("    }
  296. \n");
  297.   __c("    while (val >= 100000) {
  298. \n");
  299.   __c("        val -= 100000;
  300. \n");
  301.   __c("        pb[INT_BUF_LEN - 6]++;
  302. \n");
  303.   __c("    }
  304. \n");
  305.   __c("    while (val >= 10000) {
  306. \n");
  307.   __c("        val -= 10000;
  308. \n");
  309.   __c("        pb[INT_BUF_LEN - 5]++;
  310. \n");
  311.   __c("    }
  312. \n");
  313.   __c("    while (val >= 1000) {
  314. \n");
  315.   __c("        val -= 1000;
  316. \n");
  317.   __c("        pb[INT_BUF_LEN - 4]++;
  318. \n");
  319.   __c("    }
  320. \n");
  321.   __c("    while (val >= 100) {
  322. \n");
  323.   __c("        val -= 100;
  324. \n");
  325.   __c("        pb[INT_BUF_LEN - 3]++;
  326. \n");
  327.   __c("    }
  328. \n");
  329.   __c("    while (val >= 10) {
  330. \n");
  331.   __c("        val -= 10;
  332. \n");
  333.   __c("        pb[INT_BUF_LEN - 2]++;
  334. \n");
  335.   __c("    }
  336. \n");
  337.   __c("    while (val >= 1) {
  338. \n");
  339.   __c("        val -= 1;
  340. \n");
  341.   __c("        pb[INT_BUF_LEN - 1]++;
  342. \n");
  343.   __c("    }
  344. \n");
  345.   __c("
  346. \n");
  347.   __c("    if (neg == 1) {
  348. \n");
  349.   __c("        int c = 0;
  350. \n");
  351.   __c("        while (pb[c] == '0')
  352. \n");
  353.   __c("            c++;
  354. \n");
  355.   __c("        if (c > 0)
  356. \n");
  357.   __c("            pb[c - 1] = '-';
  358. \n");
  359.   __c("    }
  360. \n");
  361.   __c("}
  362. \n");
  363.   __c("
  364. \n");
  365.   __c("void __str_base8(char *pb, int val)
  366. \n");
  367.   __c("{
  368. \n");
  369.   __c("    int c = INT_BUF_LEN - 1;
  370. \n");
  371.   __c("    while (c > 0) {
  372. \n");
  373.   __c("        int v = val & 0x7;
  374. \n");
  375.   __c("        pb[c] = '0' + v;
  376. \n");
  377.   __c("        val = val >> 3;
  378. \n");
  379.   __c("        c--;
  380. \n");
  381.   __c("    }
  382. \n");
  383.   __c("}
  384. \n");
  385.   __c("
  386. \n");
  387.   __c("void __str_base16(char *pb, int val)
  388. \n");
  389.   __c("{
  390. \n");
  391.   __c("    int c = INT_BUF_LEN - 1;
  392. \n");
  393.   __c("    while (c > 0) {
  394. \n");
  395.   __c("        int v = val & 0xf;
  396. \n");
  397.   __c("        if (v < 10)
  398. \n");
  399.   __c("            pb[c] = '0' + v;
  400. \n");
  401.   __c("        else if (v < 16)
  402. \n");
  403.   __c("            pb[c] = 'a' + v - 10;
  404. \n");
  405.   __c("        else {
  406. \n");
  407.   __c("            abort();
  408. \n");
  409.   __c("            break;
  410. \n");
  411.   __c("        }
  412. \n");
  413.   __c("        val = val >> 4;
  414. \n");
  415.   __c("        c--;
  416. \n");
  417.   __c("    }
  418. \n");
  419.   __c("}
  420. \n");
  421.   __c("
  422. \n");
  423.   __c("int __format(char *buffer,
  424. \n");
  425.   __c("             int val,
  426. \n");
  427.   __c("             int width,
  428. \n");
  429.   __c("             int zeropad,
  430. \n");
  431.   __c("             int base,
  432. \n");
  433.   __c("             int alternate_form)
  434. \n");
  435.   __c("{
  436. \n");
  437.   __c("    int bi = 0;
  438. \n");
  439.   __c("    char pb[INT_BUF_LEN];
  440. \n");
  441.   __c("    int pbi = 0;
  442. \n");
  443.   __c("
  444. \n");
  445.   __c("    if (alternate_form == 1) {
  446. \n");
  447.   __c("        switch (base) {
  448. \n");
  449.   __c("        case 8:
  450. \n");
  451.   __c("            /* octal */
  452. \n");
  453.   __c("            buffer[0] = '0';
  454. \n");
  455.   __c("            bi = 1;
  456. \n");
  457.   __c("            width -= 1;
  458. \n");
  459.   __c("            break;
  460. \n");
  461.   __c("        case 16:
  462. \n");
  463.   __c("            /* hex */
  464. \n");
  465.   __c("            buffer[0] = '0';
  466. \n");
  467.   __c("            buffer[1] = 'x';
  468. \n");
  469.   __c("            bi = 2;
  470. \n");
  471.   __c("            width -= 2;
  472. \n");
  473.   __c("            break;
  474. \n");
  475.   __c("        default:
  476. \n");
  477.   __c("            /* decimal */
  478. \n");
  479.   __c("            /* do nothing */
  480. \n");
  481.   __c("            break;
  482. \n");
  483.   __c("        }
  484. \n");
  485.   __c("        if (width < 0)
  486. \n");
  487.   __c("            width = 0;
  488. \n");
  489.   __c("    }
  490. \n");
  491.   __c("
  492. \n");
  493.   __c("    /* set to zeroes */
  494. \n");
  495.   __c("    while (pbi < INT_BUF_LEN) {
  496. \n");
  497.   __c("        pb[pbi] = '0';
  498. \n");
  499.   __c("        pbi++;
  500. \n");
  501.   __c("    }
  502. \n");
  503.   __c("
  504. \n");
  505.   __c("    switch (base) {
  506. \n");
  507.   __c("    case 8:
  508. \n");
  509.   __c("        __str_base8(pb, val);
  510. \n");
  511.   __c("        break;
  512. \n");
  513.   __c("    case 10:
  514. \n");
  515.   __c("        __str_base10(pb, val);
  516. \n");
  517.   __c("        break;
  518. \n");
  519.   __c("    case 16:
  520. \n");
  521.   __c("        __str_base16(pb, val);
  522. \n");
  523.   __c("        break;
  524. \n");
  525.   __c("    default:
  526. \n");
  527.   __c("        abort();
  528. \n");
  529.   __c("        break;
  530. \n");
  531.   __c("    }
  532. \n");
  533.   __c("
  534. \n");
  535.   __c("    while (width > INT_BUF_LEN) {
  536. \n");
  537.   __c("        /* need to add extra padding */
  538. \n");
  539.   __c("        if (zeropad == 1)
  540. \n");
  541.   __c("            buffer[bi] = '0';
  542. \n");
  543.   __c("        else
  544. \n");
  545.   __c("            buffer[bi] = ' ';
  546. \n");
  547.   __c("        bi++;
  548. \n");
  549.   __c("        width--;
  550. \n");
  551.   __c("    }
  552. \n");
  553.   __c("
  554. \n");
  555.   __c("    /* no padding */
  556. \n");
  557.   __c("    if (width == 0) {
  558. \n");
  559.   __c("        int c = 0;
  560. \n");
  561.   __c("        int started = 0;
  562. \n");
  563.   __c("
  564. \n");
  565.   __c("        /* output from first digit */
  566. \n");
  567.   __c("        while (c < INT_BUF_LEN) {
  568. \n");
  569.   __c("            if (pb[c] != '0')
  570. \n");
  571.   __c("                started = 1;
  572. \n");
  573.   __c("            if (started) {
  574. \n");
  575.   __c("                buffer[bi] = pb[c];
  576. \n");
  577.   __c("                bi++;
  578. \n");
  579.   __c("            }
  580. \n");
  581.   __c("            c++;
  582. \n");
  583.   __c("        }
  584. \n");
  585.   __c("        /* special case - zero */
  586. \n");
  587.   __c("        if (started == 0) {
  588. \n");
  589.   __c("            buffer[bi] = '0';
  590. \n");
  591.   __c("            bi++;
  592. \n");
  593.   __c("        }
  594. \n");
  595.   __c("    } else {
  596. \n");
  597.   __c("        /* padding */
  598. \n");
  599.   __c("        int c = INT_BUF_LEN - width;
  600. \n");
  601.   __c("        int started = 0;
  602. \n");
  603.   __c("        while (c < INT_BUF_LEN) {
  604. \n");
  605.   __c("            if (pb[c] != '0')
  606. \n");
  607.   __c("                started = 1;
  608. \n");
  609.   __c("            if (started)
  610. \n");
  611.   __c("                buffer[bi] = pb[c];
  612. \n");
  613.   __c("            else if (zeropad == 1)
  614. \n");
  615.   __c("                buffer[bi] = '0';
  616. \n");
  617.   __c("            else
  618. \n");
  619.   __c("                buffer[bi] = ' ';
  620. \n");
  621.   __c("            bi++;
  622. \n");
  623.   __c("            c++;
  624. \n");
  625.   __c("        }
  626. \n");
  627.   __c("    }
  628. \n");
  629.   __c("    return bi;
  630. \n");
  631.   __c("}
  632. \n");
  633.   __c("
  634. \n");
  635.   __c("void printf(char *str, ...)
  636. \n");
  637.   __c("{
  638. \n");
  639.   __c("    int *var_args = &str + 4;
  640. \n");
  641.   __c("    char buffer[200];
  642. \n");
  643.   __c("    int si = 0, bi = 0, pi = 0;
  644. \n");
  645.   __c("
  646. \n");
  647.   __c("    while (str[si]) {
  648. \n");
  649.   __c("        if (str[si] != '%') {
  650. \n");
  651.   __c("            buffer[bi] = str[si];
  652. \n");
  653.   __c("            bi++;
  654. \n");
  655.   __c("            si++;
  656. \n");
  657.   __c("        } else {
  658. \n");
  659.   __c("            int w = 0, zp = 0, pp = 0;
  660. \n");
  661.   __c("
  662. \n");
  663.   __c("            si++;
  664. \n");
  665.   __c("            if (str[si] == '#') {
  666. \n");
  667.   __c("                pp = 1;
  668. \n");
  669.   __c("                si++;
  670. \n");
  671.   __c("            }
  672. \n");
  673.   __c("            if (str[si] == '0') {
  674. \n");
  675.   __c("                zp = 1;
  676. \n");
  677.   __c("                si++;
  678. \n");
  679.   __c("            }
  680. \n");
  681.   __c("            if (str[si] >= '1' && str[si] <= '9') {
  682. \n");
  683.   __c("                w = str[si] - '0';
  684. \n");
  685.   __c("                si++;
  686. \n");
  687.   __c("                while (str[si] >= '0' && str[si] <= '9') {
  688. \n");
  689.   __c("                    w = w * 10;
  690. \n");
  691.   __c("                    w += str[si] - '0';
  692. \n");
  693.   __c("                    si++;
  694. \n");
  695.   __c("                }
  696. \n");
  697.   __c("            }
  698. \n");
  699.   __c("            if (str[si] == 's') {
  700. \n");
  701.   __c("                /* append param pi as string */
  702. \n");
  703.   __c("                int l = strlen(var_args[pi]);
  704. \n");
  705.   __c("                strcpy(buffer + bi, var_args[pi]);
  706. \n");
  707.   __c("                bi += l;
  708. \n");
  709.   __c("            } else if (str[si] == 'c') {
  710. \n");
  711.   __c("                /* append param pi as char */
  712. \n");
  713.   __c("                buffer[bi] = var_args[pi];
  714. \n");
  715.   __c("                bi += 1;
  716. \n");
  717.   __c("            } else if (str[si] == 'o') {
  718. \n");
  719.   __c("                /* append param as octal */
  720. \n");
  721.   __c("                int v = var_args[pi];
  722. \n");
  723.   __c("                bi += __format(buffer + bi, v, w, zp, 8, pp);
  724. \n");
  725.   __c("            } else if (str[si] == 'd') {
  726. \n");
  727.   __c("                /* append param as decimal */
  728. \n");
  729.   __c("                int v = var_args[pi];
  730. \n");
  731.   __c("                bi += __format(buffer + bi, v, w, zp, 10, 0);
  732. \n");
  733.   __c("            } else if (str[si] == 'x') {
  734. \n");
  735.   __c("                /* append param as hex */
  736. \n");
  737.   __c("                int v = var_args[pi];
  738. \n");
  739.   __c("                bi += __format(buffer + bi, v, w, zp, 16, pp);
  740. \n");
  741.   __c("            } else if (str[si] == '%') {
  742. \n");
  743.   __c("                /* append literal '%' character */
  744. \n");
  745.   __c("                buffer[bi] = '%';
  746. \n");
  747.   __c("                bi++;
  748. \n");
  749.   __c("                si++;
  750. \n");
  751.   __c("                continue;
  752. \n");
  753.   __c("            }
  754. \n");
  755.   __c("            pi++;
  756. \n");
  757.   __c("            si++;
  758. \n");
  759.   __c("        }
  760. \n");
  761.   __c("    }
  762. \n");
  763.   __c("    buffer[bi] = 0;
  764. \n");
  765.   __c("    __syscall(__syscall_write, 1, buffer, bi);
  766. \n");
  767.   __c("}
  768. \n");
  769.   __c("
  770. \n");
  771.   __c("void sprintf(char *buffer, char *str, ...)
  772. \n");
  773.   __c("{
  774. \n");
  775.   __c("    int *var_args = &str + 4;
  776. \n");
  777.   __c("    int si = 0, bi = 0, pi = 0;
  778. \n");
  779.   __c("
  780. \n");
  781.   __c("    while (str[si]) {
  782. \n");
  783.   __c("        if (str[si] != '%') {
  784. \n");
  785.   __c("            buffer[bi] = str[si];
  786. \n");
  787.   __c("            bi++;
  788. \n");
  789.   __c("            si++;
  790. \n");
  791.   __c("        } else {
  792. \n");
  793.   __c("            int w = 0, zp = 0, pp = 0;
  794. \n");
  795.   __c("
  796. \n");
  797.   __c("            si++;
  798. \n");
  799.   __c("            if (str[si] == '#') {
  800. \n");
  801.   __c("                pp = 1;
  802. \n");
  803.   __c("                si++;
  804. \n");
  805.   __c("            }
  806. \n");
  807.   __c("            if (str[si] == '0') {
  808. \n");
  809.   __c("                zp = 1;
  810. \n");
  811.   __c("                si++;
  812. \n");
  813.   __c("            }
  814. \n");
  815.   __c("            if (str[si] >= '1' && str[si] <= '9') {
  816. \n");
  817.   __c("                w = str[si] - '0';
  818. \n");
  819.   __c("                si++;
  820. \n");
  821.   __c("                if (str[si] >= '0' && str[si] <= '9') {
  822. \n");
  823.   __c("                    w = w * 10;
  824. \n");
  825.   __c("                    w += str[si] - '0';
  826. \n");
  827.   __c("                    si++;
  828. \n");
  829.   __c("                }
  830. \n");
  831.   __c("            }
  832. \n");
  833.   __c("            switch (str[si]) {
  834. \n");
  835.   __c("            case 37: /* % */
  836. \n");
  837.   __c("                buffer[bi++] = '%';
  838. \n");
  839.   __c("                si++;
  840. \n");
  841.   __c("                continue;
  842. \n");
  843.   __c("            case 99: /* c */
  844. \n");
  845.   __c("                buffer[bi++] = var_args[pi];
  846. \n");
  847.   __c("                break;
  848. \n");
  849.   __c("            case 115: /* s */
  850. \n");
  851.   __c("                strcpy(buffer + bi, var_args[pi]);
  852. \n");
  853.   __c("                bi += strlen(var_args[pi]);
  854. \n");
  855.   __c("                break;
  856. \n");
  857.   __c("            case 111: /* o */
  858. \n");
  859.   __c("                bi += __format(buffer + bi, var_args[pi], w, zp, 8, pp);
  860. \n");
  861.   __c("                break;
  862. \n");
  863.   __c("            case 100: /* d */
  864. \n");
  865.   __c("                bi += __format(buffer + bi, var_args[pi], w, zp, 10, 0);
  866. \n");
  867.   __c("                break;
  868. \n");
  869.   __c("            case 120: /* x */
  870. \n");
  871.   __c("                bi += __format(buffer + bi, var_args[pi], w, zp, 16, pp);
  872. \n");
  873.   __c("                break;
  874. \n");
  875.   __c("            default:
  876. \n");
  877.   __c("                abort();
  878. \n");
  879.   __c("                break;
  880. \n");
  881.   __c("            }
  882. \n");
  883.   __c("            pi++;
  884. \n");
  885.   __c("            si++;
  886. \n");
  887.   __c("        }
  888. \n");
  889.   __c("    }
  890. \n");
  891.   __c("    buffer[bi] = 0;
  892. \n");
  893.   __c("}
  894. \n");
  895.   __c("
  896. \n");
  897.   __c("int __free_all();
  898. \n");
  899.   __c("
  900. \n");
  901.   __c("void exit(int exit_code)
  902. \n");
  903.   __c("{
  904. \n");
  905.   __c("    __free_all();
  906. \n");
  907.   __c("    __syscall(__syscall_exit, exit_code);
  908. \n");
  909.   __c("}
  910. \n");
  911.   __c("
  912. \n");
  913.   __c("void abort()
  914. \n");
  915.   __c("{
  916. \n");
  917.   __c("    printf(\"Abnormal program termination\n\");
  918. \n");
  919.   __c("    exit(-1);
  920. \n");
  921.   __c("}
  922. \n");
  923.   __c("
  924. \n");
  925.   __c("FILE *fopen(char *filename, char *mode)
  926. \n");
  927.   __c("{
  928. \n");
  929.   __c("    if (!strcmp(mode, \"wb\")) {
  930. \n");
  931.   __c("#if defined(__arm__)
  932. \n");
  933.   __c("        return __syscall(__syscall_open, filename, 65, 0x1fd);
  934. \n");
  935.   __c("#elif defined(__riscv)
  936. \n");
  937.   __c("        /* FIXME: mode not work currently in RISC-V */
  938. \n");
  939.   __c("        return __syscall(__syscall_openat, -100, filename, 65, 0x1fd);
  940. \n");
  941.   __c("#endif
  942. \n");
  943.   __c("    }
  944. \n");
  945.   __c("    if (!strcmp(mode, \"rb\")) {
  946. \n");
  947.   __c("#if defined(__arm__)
  948. \n");
  949.   __c("        return __syscall(__syscall_open, filename, 0, 0);
  950. \n");
  951.   __c("#elif defined(__riscv)
  952. \n");
  953.   __c("        return __syscall(__syscall_openat, -100, filename, 0, 0);
  954. \n");
  955.   __c("#endif
  956. \n");
  957.   __c("    }
  958. \n");
  959.   __c("    return NULL;
  960. \n");
  961.   __c("}
  962. \n");
  963.   __c("
  964. \n");
  965.   __c("int fclose(FILE *stream)
  966. \n");
  967.   __c("{
  968. \n");
  969.   __c("    __syscall(__syscall_close, stream);
  970. \n");
  971.   __c("    return 0;
  972. \n");
  973.   __c("}
  974. \n");
  975.   __c("
  976. \n");
  977.   __c("/* Read a byte from file descriptor. So the return value is either in the range
  978. \n");
  979.   __c(" * of 0 to 127 for the character, or -1 on the end of file. */
  980. \n");
  981.   __c("int fgetc(FILE *stream)
  982. \n");
  983.   __c("{
  984. \n");
  985.   __c("    int buf = 0, r = __syscall(__syscall_read, stream, &buf, 1);
  986. \n");
  987.   __c("    if (r < 1)
  988. \n");
  989.   __c("        return -1;
  990. \n");
  991.   __c("    return buf;
  992. \n");
  993.   __c("}
  994. \n");
  995.   __c("
  996. \n");
  997.   __c("char *fgets(char *str, int n, FILE *stream)
  998. \n");
  999.   __c("{
  1000. \n");
  1001.   __c("    int i;
  1002. \n");
  1003.   __c("    for (i = 0; i < n - 1; i++) {
  1004. \n");
  1005.   __c("        int c = fgetc(stream);
  1006. \n");
  1007.   __c("        if (c == -1) {
  1008. \n");
  1009.   __c("            if (i == 0)
  1010. \n");
  1011.   __c("                /* EOF on first char */
  1012. \n");
  1013.   __c("                return NULL;
  1014. \n");
  1015.   __c("            /* EOF in the middle */
  1016. \n");
  1017.   __c("            str[i] = 0;
  1018. \n");
  1019.   __c("            return str;
  1020. \n");
  1021.   __c("        }
  1022. \n");
  1023.   __c("        /* Not support casting yet. Simply assign it. */
  1024. \n");
  1025.   __c("        str[i] = c;
  1026. \n");
  1027.   __c("
  1028. \n");
  1029.   __c("        if (c == '\n') {
  1030. \n");
  1031.   __c("            str[i + 1] = 0;
  1032. \n");
  1033.   __c("            return str;
  1034. \n");
  1035.   __c("        }
  1036. \n");
  1037.   __c("    }
  1038. \n");
  1039.   __c("    str[i] = 0;
  1040. \n");
  1041.   __c("    return str;
  1042. \n");
  1043.   __c("}
  1044. \n");
  1045.   __c("
  1046. \n");
  1047.   __c("int fputc(int c, FILE *stream)
  1048. \n");
  1049.   __c("{
  1050. \n");
  1051.   __c("    char buf[1];
  1052. \n");
  1053.   __c("    buf[0] = c;
  1054. \n");
  1055.   __c("    __syscall(__syscall_write, stream, buf, 1);
  1056. \n");
  1057.   __c("    return 0;
  1058. \n");
  1059.   __c("}
  1060. \n");
  1061.   __c("
  1062. \n");
  1063.   __c("/* Non-portable: Assume page size is 4KiB */
  1064. \n");
  1065.   __c("#define PAGESIZE 4096
  1066. \n");
  1067.   __c("
  1068. \n");
  1069.   __c("#define CHUNK_SIZE_FREED_MASK 1
  1070. \n");
  1071.   __c("#define CHUNK_SIZE_SZ_MASK 0xFFFFFFFE
  1072. \n");
  1073.   __c("#define CHUNK_GET_SIZE(size) (size & CHUNK_SIZE_SZ_MASK)
  1074. \n");
  1075.   __c("#define IS_CHUNK_GET_FREED(size) (size & CHUNK_SIZE_FREED_MASK)
  1076. \n");
  1077.   __c("
  1078. \n");
  1079.   __c("typedef struct chunk {
  1080. \n");
  1081.   __c("    struct chunk *next;
  1082. \n");
  1083.   __c("    struct chunk *prev;
  1084. \n");
  1085.   __c("    int size;
  1086. \n");
  1087.   __c("} chunk_t;
  1088. \n");
  1089.   __c("
  1090. \n");
  1091.   __c("void chunk_set_freed(chunk_t *chunk)
  1092. \n");
  1093.   __c("{
  1094. \n");
  1095.   __c("    chunk->size |= CHUNK_SIZE_FREED_MASK;
  1096. \n");
  1097.   __c("}
  1098. \n");
  1099.   __c("
  1100. \n");
  1101.   __c("void chunk_clear_freed(chunk_t *chunk)
  1102. \n");
  1103.   __c("{
  1104. \n");
  1105.   __c("    chunk->size &= CHUNK_SIZE_SZ_MASK;
  1106. \n");
  1107.   __c("}
  1108. \n");
  1109.   __c("
  1110. \n");
  1111.   __c("int __align_up(int size)
  1112. \n");
  1113.   __c("{
  1114. \n");
  1115.   __c("    int mask = PAGESIZE - 1;
  1116. \n");
  1117.   __c("    return ((size - 1) | mask) + 1;
  1118. \n");
  1119.   __c("}
  1120. \n");
  1121.   __c("
  1122. \n");
  1123.   __c("chunk_t *__alloc_head;
  1124. \n");
  1125.   __c("chunk_t *__alloc_tail;
  1126. \n");
  1127.   __c("chunk_t *__freelist_head;
  1128. \n");
  1129.   __c("
  1130. \n");
  1131.   __c("void *malloc(int size)
  1132. \n");
  1133.   __c("{
  1134. \n");
  1135.   __c("    if (size <= 0)
  1136. \n");
  1137.   __c("        return NULL;
  1138. \n");
  1139.   __c("
  1140. \n");
  1141.   __c("    int flags = 34; /* MAP_PRIVATE (0x02) | MAP_ANONYMOUS (0x20) */
  1142. \n");
  1143.   __c("    int prot = 3;   /* PROT_READ (0x01) | PROT_WRITE (0x02) */
  1144. \n");
  1145.   __c("
  1146. \n");
  1147.   __c("    if (!__alloc_head) {
  1148. \n");
  1149.   __c("        chunk_t *tmp =
  1150. \n");
  1151.   __c("            __syscall(__syscall_mmap2, NULL, __align_up(sizeof(chunk_t)), prot,
  1152. \n");
  1153.   __c("                      flags, -1, 0);
  1154. \n");
  1155.   __c("        __alloc_head = tmp;
  1156. \n");
  1157.   __c("        __alloc_tail = tmp;
  1158. \n");
  1159.   __c("        __alloc_head->next = NULL;
  1160. \n");
  1161.   __c("        __alloc_head->prev = NULL;
  1162. \n");
  1163.   __c("        __alloc_head->size = 0;
  1164. \n");
  1165.   __c("    }
  1166. \n");
  1167.   __c("
  1168. \n");
  1169.   __c("    if (!__freelist_head) {
  1170. \n");
  1171.   __c("        chunk_t *tmp =
  1172. \n");
  1173.   __c("            __syscall(__syscall_mmap2, NULL, __align_up(sizeof(chunk_t)), prot,
  1174. \n");
  1175.   __c("                      flags, -1, 0);
  1176. \n");
  1177.   __c("        __freelist_head = tmp;
  1178. \n");
  1179.   __c("        __freelist_head->next = NULL;
  1180. \n");
  1181.   __c("        __freelist_head->prev = NULL;
  1182. \n");
  1183.   __c("        __freelist_head->size = -1;
  1184. \n");
  1185.   __c("    }
  1186. \n");
  1187.   __c("
  1188. \n");
  1189.   __c("    /* to search the best chunk */
  1190. \n");
  1191.   __c("    chunk_t *best_fit_chunk = NULL;
  1192. \n");
  1193.   __c("    chunk_t *allocated;
  1194. \n");
  1195.   __c("
  1196. \n");
  1197.   __c("    if (!__freelist_head->next) {
  1198. \n");
  1199.   __c("        /* If no more chunks in the free chunk list, allocate best_fit_chunk
  1200. \n");
  1201.   __c("         * as NULL.
  1202. \n");
  1203.   __c("         */
  1204. \n");
  1205.   __c("        allocated = best_fit_chunk;
  1206. \n");
  1207.   __c("    } else {
  1208. \n");
  1209.   __c("        /* record the size of the chunk */
  1210. \n");
  1211.   __c("        int bsize = 0;
  1212. \n");
  1213.   __c("
  1214. \n");
  1215.   __c("        for (chunk_t *fh = __freelist_head; fh->next; fh = fh->next) {
  1216. \n");
  1217.   __c("            int fh_size = CHUNK_GET_SIZE(fh->size);
  1218. \n");
  1219.   __c("            if (fh_size >= size && !best_fit_chunk) {
  1220. \n");
  1221.   __c("                /* first time setting fh as best_fit_chunk */
  1222. \n");
  1223.   __c("                best_fit_chunk = fh;
  1224. \n");
  1225.   __c("                bsize = fh_size;
  1226. \n");
  1227.   __c("            } else if ((fh_size >= size) && best_fit_chunk &&
  1228. \n");
  1229.   __c("                       (fh_size < bsize)) {
  1230. \n");
  1231.   __c("                /* If there is a smaller chunk available, replace it. */
  1232. \n");
  1233.   __c("                best_fit_chunk = fh;
  1234. \n");
  1235.   __c("                bsize = fh_size;
  1236. \n");
  1237.   __c("            }
  1238. \n");
  1239.   __c("        }
  1240. \n");
  1241.   __c("
  1242. \n");
  1243.   __c("        /* a suitable chunk has been found */
  1244. \n");
  1245.   __c("        if (best_fit_chunk) {
  1246. \n");
  1247.   __c("            /* remove the chunk from the freelist */
  1248. \n");
  1249.   __c("            if (best_fit_chunk->prev) {
  1250. \n");
  1251.   __c("                chunk_t *tmp = best_fit_chunk->prev;
  1252. \n");
  1253.   __c("                tmp->next = best_fit_chunk->next;
  1254. \n");
  1255.   __c("            } else
  1256. \n");
  1257.   __c("                __freelist_head = best_fit_chunk->next;
  1258. \n");
  1259.   __c("
  1260. \n");
  1261.   __c("            if (best_fit_chunk->next) {
  1262. \n");
  1263.   __c("                chunk_t *tmp = best_fit_chunk->next;
  1264. \n");
  1265.   __c("                tmp->prev = best_fit_chunk->prev;
  1266. \n");
  1267.   __c("            }
  1268. \n");
  1269.   __c("        }
  1270. \n");
  1271.   __c("        allocated = best_fit_chunk;
  1272. \n");
  1273.   __c("    }
  1274. \n");
  1275.   __c("
  1276. \n");
  1277.   __c("    if (!allocated) {
  1278. \n");
  1279.   __c("        allocated =
  1280. \n");
  1281.   __c("            __syscall(__syscall_mmap2, NULL, __align_up(sizeof(chunk_t) + size),
  1282. \n");
  1283.   __c("                      prot, flags, -1, 0);
  1284. \n");
  1285.   __c("        allocated->size = __align_up(sizeof(chunk_t) + size);
  1286. \n");
  1287.   __c("    }
  1288. \n");
  1289.   __c("
  1290. \n");
  1291.   __c("    __alloc_tail->next = allocated;
  1292. \n");
  1293.   __c("    allocated->prev = __alloc_tail;
  1294. \n");
  1295.   __c("
  1296. \n");
  1297.   __c("    __alloc_tail = allocated;
  1298. \n");
  1299.   __c("    __alloc_tail->next = NULL;
  1300. \n");
  1301.   __c("    __alloc_tail->size = allocated->size;
  1302. \n");
  1303.   __c("    chunk_clear_freed(__alloc_tail);
  1304. \n");
  1305.   __c("    void *ptr = __alloc_tail + 1;
  1306. \n");
  1307.   __c("    return ptr;
  1308. \n");
  1309.   __c("}
  1310. \n");
  1311.   __c("
  1312. \n");
  1313.   __c("void *calloc(int n, int size)
  1314. \n");
  1315.   __c("{
  1316. \n");
  1317.   __c("    char *p = malloc(n * size);
  1318. \n");
  1319.   __c("    for (int i = 0; i < n * size; i++)
  1320. \n");
  1321.   __c("        p[i] = 0;
  1322. \n");
  1323.   __c("    return p;
  1324. \n");
  1325.   __c("}
  1326. \n");
  1327.   __c("
  1328. \n");
  1329.   __c("void __rfree(void *ptr, int size)
  1330. \n");
  1331.   __c("{
  1332. \n");
  1333.   __c("    if (!ptr)
  1334. \n");
  1335.   __c("        return;
  1336. \n");
  1337.   __c("    __syscall(__syscall_munmap, ptr, size);
  1338. \n");
  1339.   __c("}
  1340. \n");
  1341.   __c("
  1342. \n");
  1343.   __c("int __free_all()
  1344. \n");
  1345.   __c("{
  1346. \n");
  1347.   __c("    if (!__freelist_head && !__alloc_head)
  1348. \n");
  1349.   __c("        return 0;
  1350. \n");
  1351.   __c("
  1352. \n");
  1353.   __c("    chunk_t *cur = __freelist_head;
  1354. \n");
  1355.   __c("    chunk_t *rel;
  1356. \n");
  1357.   __c("    int size;
  1358. \n");
  1359.   __c("
  1360. \n");
  1361.   __c("    /* release freelist */
  1362. \n");
  1363.   __c("    while (cur->next) {
  1364. \n");
  1365.   __c("        rel = cur;
  1366. \n");
  1367.   __c("        cur = cur->next;
  1368. \n");
  1369.   __c("        rel->next = NULL;
  1370. \n");
  1371.   __c("        rel->prev = NULL;
  1372. \n");
  1373.   __c("        size = CHUNK_GET_SIZE(rel->size);
  1374. \n");
  1375.   __c("        __rfree(rel, size);
  1376. \n");
  1377.   __c("    }
  1378. \n");
  1379.   __c("
  1380. \n");
  1381.   __c("    if (__alloc_head->next) {
  1382. \n");
  1383.   __c("        cur = __alloc_head->next;
  1384. \n");
  1385.   __c("        /* release chunks which not be free */
  1386. \n");
  1387.   __c("        while (cur) {
  1388. \n");
  1389.   __c("            rel = cur;
  1390. \n");
  1391.   __c("            cur = cur->next;
  1392. \n");
  1393.   __c("            rel->next = NULL;
  1394. \n");
  1395.   __c("            rel->prev = NULL;
  1396. \n");
  1397.   __c("            size = CHUNK_GET_SIZE(rel->size);
  1398. \n");
  1399.   __c("            __rfree(rel, size);
  1400. \n");
  1401.   __c("        }
  1402. \n");
  1403.   __c("    }
  1404. \n");
  1405.   __c("    return 0;
  1406. \n");
  1407.   __c("}
  1408. \n");
  1409.   __c("
  1410. \n");
  1411.   __c("void free(void *ptr)
  1412. \n");
  1413.   __c("{
  1414. \n");
  1415.   __c("    if (!ptr)
  1416. \n");
  1417.   __c("        return;
  1418. \n");
  1419.   __c("
  1420. \n");
  1421.   __c("    char *__ptr = ptr;
  1422. \n");
  1423.   __c("    chunk_t *cur = __ptr - sizeof(chunk_t);
  1424. \n");
  1425.   __c("    if (IS_CHUNK_GET_FREED(cur->size)) {
  1426. \n");
  1427.   __c("        printf(\"free(): double free detected\n\");
  1428. \n");
  1429.   __c("        abort();
  1430. \n");
  1431.   __c("    }
  1432. \n");
  1433.   __c("
  1434. \n");
  1435.   __c("    chunk_t *prev;
  1436. \n");
  1437.   __c("    if (cur->prev) {
  1438. \n");
  1439.   __c("        prev = cur->prev;
  1440. \n");
  1441.   __c("        prev->next = cur->next;
  1442. \n");
  1443.   __c("    } else
  1444. \n");
  1445.   __c("        __alloc_head = cur->next;
  1446. \n");
  1447.   __c("
  1448. \n");
  1449.   __c("    if (cur->next) {
  1450. \n");
  1451.   __c("        chunk_t *next = cur->next;
  1452. \n");
  1453.   __c("        next->prev = cur->prev;
  1454. \n");
  1455.   __c("    } else {
  1456. \n");
  1457.   __c("        prev->next = NULL;
  1458. \n");
  1459.   __c("        __alloc_tail = prev;
  1460. \n");
  1461.   __c("    }
  1462. \n");
  1463.   __c("
  1464. \n");
  1465.   __c("    /* Insert head in __freelist_head */
  1466. \n");
  1467.   __c("    cur->next = __freelist_head;
  1468. \n");
  1469.   __c("    cur->prev = NULL;
  1470. \n");
  1471.   __c("    chunk_set_freed(cur);
  1472. \n");
  1473.   __c("    __freelist_head->prev = cur;
  1474. \n");
  1475.   __c("    __freelist_head = cur;
  1476. \n");
  1477.   __c("}
  1478. \n");
  1479. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!