Ignore:
Timestamp:
Jan 21, 2018, 12:10:09 AM (6 years ago)
Author:
coas-nagasima
Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

Location:
EcnlProtoTool/trunk/tcc-0.9.27
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/tcc-0.9.27/lib/bcheck.c

    r321 r331  
    2222#include <stdarg.h>
    2323#include <string.h>
    24 #if !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__) \
    25     && !defined(__DragonFly__) && !defined(__OpenBSD__)
     24
     25#if !defined(__FreeBSD__) \
     26 && !defined(__FreeBSD_kernel__) \
     27 && !defined(__DragonFly__) \
     28 && !defined(__OpenBSD__) \
     29 && !defined(__NetBSD__)
    2630#include <malloc.h>
    2731#endif
     32
    2833#if !defined(_WIN32)
    2934#include <unistd.h>
    3035#endif
    3136
    32 //#define BOUND_DEBUG
     37/* #define BOUND_DEBUG */
     38
     39#ifdef BOUND_DEBUG
     40 #define dprintf(a...) fprintf(a)
     41#else
     42 #define dprintf(a...)
     43#endif
    3344
    3445/* define so that bound array is static (faster, but use memory if
    3546   bound checking not used) */
    36 //#define BOUND_STATIC
     47/* #define BOUND_STATIC */
    3748
    3849/* use malloc hooks. Currently the code cannot be reliable if no hooks */
    … …  
    4051#define HAVE_MEMALIGN
    4152
    42 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
    43     || defined(__DragonFly__) || defined(__dietlibc__) \
    44     || defined(__UCLIBC__) || defined(__OpenBSD__) \
    45     || defined(_WIN32) || defined(TCC_UCLIBC)
    46 #warning Bound checking does not support malloc (etc.) in this environment.
     53#if defined(__FreeBSD__) \
     54 || defined(__FreeBSD_kernel__) \
     55 || defined(__DragonFly__) \
     56 || defined(__OpenBSD__) \
     57 || defined(__NetBSD__) \
     58 || defined(__dietlibc__) \
     59 || defined(_WIN32)
     60//#warning Bound checking does not support malloc (etc.) in this environment.
    4761#undef CONFIG_TCC_MALLOC_HOOKS
    4862#undef HAVE_MEMALIGN
    … …  
    5165#define BOUND_T1_BITS 13
    5266#define BOUND_T2_BITS 11
    53 #define BOUND_T3_BITS (32 - BOUND_T1_BITS - BOUND_T2_BITS)
    54 
    55 #define BOUND_T1_SIZE (1 << BOUND_T1_BITS)
    56 #define BOUND_T2_SIZE (1 << BOUND_T2_BITS)
    57 #define BOUND_T3_SIZE (1 << BOUND_T3_BITS)
    58 #define BOUND_E_BITS  4
     67#define BOUND_T3_BITS (sizeof(size_t)*8 - BOUND_T1_BITS - BOUND_T2_BITS)
     68#define BOUND_E_BITS  (sizeof(size_t))
     69
     70#define BOUND_T1_SIZE ((size_t)1 << BOUND_T1_BITS)
     71#define BOUND_T2_SIZE ((size_t)1 << BOUND_T2_BITS)
     72#define BOUND_T3_SIZE ((size_t)1 << BOUND_T3_BITS)
    5973
    6074#define BOUND_T23_BITS (BOUND_T2_BITS + BOUND_T3_BITS)
    61 #define BOUND_T23_SIZE (1 << BOUND_T23_BITS)
     75#define BOUND_T23_SIZE ((size_t)1 << BOUND_T23_BITS)
    6276
    6377
    … …  
    6579#define INVALID_POINTER ((void *)(-2))
    6680/* size of an empty region */
    67 #define EMPTY_SIZE        0xffffffff
     81#define EMPTY_SIZE  ((size_t)(-1))
    6882/* size of an invalid region */
    6983#define INVALID_SIZE      0
    7084
    7185typedef struct BoundEntry {
    72     unsigned long start;
    73     unsigned long size;
     86    size_t start;
     87    size_t size;
    7488    struct BoundEntry *next;
    75     unsigned long is_invalid; /* true if pointers outside region are invalid */
     89    size_t is_invalid; /* true if pointers outside region are invalid */
    7690} BoundEntry;
    7791
    7892/* external interface */
    7993void __bound_init(void);
    80 void __bound_new_region(void *p, unsigned long size);
     94void __bound_new_region(void *p, size_t size);
    8195int __bound_delete_region(void *p);
    8296
     97#ifdef __attribute__
     98  /* an __attribute__ macro is defined in the system headers */
     99  #undef __attribute__
     100#endif
    83101#define FASTCALL __attribute__((regparm(3)))
    84102
    … …  
    105123
    106124/* runtime error output */
    107 extern void rt_error(unsigned long pc, const char *fmt, ...);
     125extern void rt_error(size_t pc, const char *fmt, ...);
    108126
    109127#ifdef BOUND_STATIC
    … …  
    117135static BoundEntry *__bound_find_region(BoundEntry *e1, void *p)
    118136{
    119     unsigned long addr, tmp;
     137    size_t addr, tmp;
    120138    BoundEntry *e;
    121139
    122140    e = e1;
    123141    while (e != NULL) {
    124         addr = (unsigned long)p;
     142        addr = (size_t)p;
    125143        addr -= e->start;
    126144        if (addr <= e->size) {
    … …  
    147165{
    148166    __bound_error_msg = fmt;
    149     *(int *)0 = 0; /* force a runtime error */
     167    fprintf(stderr,"%s %s: %s\n", __FILE__, __FUNCTION__, fmt);
     168    *(void **)0 = 0; /* force a runtime error */
    150169}
    151170
    … …  
    157176/* return '(p + offset)' for pointer arithmetic (a pointer can reach
    158177   the end of a region in this case */
    159 void * FASTCALL __bound_ptr_add(void *p, int offset)
    160 {
    161     unsigned long addr = (unsigned long)p;
     178void * FASTCALL __bound_ptr_add(void *p, size_t offset)
     179{
     180    size_t addr = (size_t)p;
    162181    BoundEntry *e;
    163 #if defined(BOUND_DEBUG)
    164     printf("add: 0x%x %d\n", (int)p, offset);
    165 #endif
     182
     183    dprintf(stderr, "%s %s: %p %x\n",
     184        __FILE__, __FUNCTION__, p, (unsigned)offset);
     185
     186    __bound_init();
    166187
    167188    e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)];
    … …  
    172193    if (addr > e->size) {
    173194        e = __bound_find_region(e, p);
    174         addr = (unsigned long)p - e->start;
     195        addr = (size_t)p - e->start;
    175196    }
    176197    addr += offset;
    177     if (addr > e->size)
     198    if (addr >= e->size) {
     199        fprintf(stderr,"%s %s: %p is outside of the region\n",
     200            __FILE__, __FUNCTION__, p + offset);
    178201        return INVALID_POINTER; /* return an invalid pointer */
     202    }
    179203    return p + offset;
    180204}
    … …  
    183207   be strictly inside the region */
    184208#define BOUND_PTR_INDIR(dsize)                                          \
    185 void * FASTCALL __bound_ptr_indir ## dsize (void *p, int offset)        \
     209void * FASTCALL __bound_ptr_indir ## dsize (void *p, size_t offset)     \
    186210{                                                                       \
    187     unsigned long addr = (unsigned long)p;                              \
     211    size_t addr = (size_t)p;                                            \
    188212    BoundEntry *e;                                                      \
    189213                                                                        \
     214    dprintf(stderr, "%s %s: %p %x start\n",                             \
     215        __FILE__, __FUNCTION__, p, (unsigned)offset);                   \
     216                                                                        \
     217    __bound_init();                                                     \
    190218    e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)];            \
    191219    e = (BoundEntry *)((char *)e +                                      \
    … …  
    195223    if (addr > e->size) {                                               \
    196224        e = __bound_find_region(e, p);                                  \
    197         addr = (unsigned long)p - e->start;                             \
     225        addr = (size_t)p - e->start;                                    \
    198226    }                                                                   \
    199227    addr += offset + dsize;                                             \
    200     if (addr > e->size)                                                 \
     228    if (addr > e->size) {                                               \
     229        fprintf(stderr,"%s %s: %p is outside of the region\n",          \
     230            __FILE__, __FUNCTION__, p + offset);                        \
    201231        return INVALID_POINTER; /* return an invalid pointer */         \
     232    }                                                                   \
     233    dprintf(stderr, "%s %s: return p+offset = %p\n",                    \
     234        __FILE__, __FUNCTION__, p + offset);                            \
    202235    return p + offset;                                                  \
    203236}
    … …  
    210243BOUND_PTR_INDIR(16)
    211244
     245#if defined(__GNUC__) && (__GNUC__ >= 6)
     246/*
     247 * At least gcc 6.2 complains when __builtin_frame_address is used with
     248 * nonzero argument.
     249 */
     250#pragma GCC diagnostic push
     251#pragma GCC diagnostic ignored "-Wframe-address"
     252#endif
     253
    212254/* return the frame pointer of the caller */
    213255#define GET_CALLER_FP(fp)\
    214256{\
    215     fp = (unsigned long)__builtin_frame_address(1);\
     257    fp = (size_t)__builtin_frame_address(1);\
    216258}
    217259
    … …  
    219261void FASTCALL __bound_local_new(void *p1)
    220262{
    221     unsigned long addr, size, fp, *p = p1;
     263    size_t addr, size, fp, *p = p1;
     264
     265    dprintf(stderr, "%s, %s start p1=%p\n", __FILE__, __FUNCTION__, p);
    222266    GET_CALLER_FP(fp);
    223267    for(;;) {
    … …  
    230274        __bound_new_region((void *)addr, size);
    231275    }
     276    dprintf(stderr, "%s, %s end\n", __FILE__, __FUNCTION__);
    232277}
    233278
    … …  
    235280void FASTCALL __bound_local_delete(void *p1)
    236281{
    237     unsigned long addr, fp, *p = p1;
     282    size_t addr, fp, *p = p1;
    238283    GET_CALLER_FP(fp);
    239284    for(;;) {
    … …  
    247292}
    248293
     294#if defined(__GNUC__) && (__GNUC__ >= 6)
     295#pragma GCC diagnostic pop
     296#endif
     297
    249298static BoundEntry *__bound_new_page(void)
    250299{
    251300    BoundEntry *page;
    252     int i;
     301    size_t i;
    253302
    254303    page = libc_malloc(sizeof(BoundEntry) * BOUND_T2_SIZE);
    … …  
    278327}
    279328
    280 static inline BoundEntry *get_page(int index)
     329static BoundEntry *get_page(size_t index)
    281330{
    282331    BoundEntry *page;
    283332    page = __bound_t1[index];
    284     if (page == __bound_empty_t2 || page == __bound_invalid_t2) {
     333    if (!page || page == __bound_empty_t2 || page == __bound_invalid_t2) {
    285334        /* create a new page if necessary */
    286335        page = __bound_new_page();
    … …  
    291340
    292341/* mark a region as being invalid (can only be used during init) */
    293 static void mark_invalid(unsigned long addr, unsigned long size)
    294 {
    295     unsigned long start, end;
     342static void mark_invalid(size_t addr, size_t size)
     343{
     344    size_t start, end;
    296345    BoundEntry *page;
    297     int t1_start, t1_end, i, j, t2_start, t2_end;
     346    size_t t1_start, t1_end, i, j, t2_start, t2_end;
    298347
    299348    start = addr;
    … …  
    307356
    308357#if 0
    309     printf("mark_invalid: start = %x %x\n", t2_start, t2_end);
     358    dprintf(stderr, "mark_invalid: start = %x %x\n", t2_start, t2_end);
    310359#endif
    311360   
    … …  
    346395void __bound_init(void)
    347396{
    348     int i;
     397    size_t i;
    349398    BoundEntry *page;
    350     unsigned long start, size;
    351     int *p;
     399    size_t start, size;
     400    size_t *p;
     401
     402    static int inited;
     403    if (inited)
     404        return;
     405
     406    inited = 1;
     407
     408    dprintf(stderr, "%s, %s() start\n", __FILE__, __FUNCTION__);
    352409
    353410    /* save malloc hooks and install bound check hooks */
    … …  
    375432
    376433    /* invalid pointer zone */
    377     start = (unsigned long)INVALID_POINTER & ~(BOUND_T23_SIZE - 1);
     434    start = (size_t)INVALID_POINTER & ~(BOUND_T23_SIZE - 1);
    378435    size = BOUND_T23_SIZE;
    379436    mark_invalid(start, size);
    … …  
    406463     *     start_brk from /proc/self/stat
    407464     */
    408     start = (unsigned long)sbrk(0);
     465    start = (size_t)sbrk(0);
    409466    size = 128 * 0x100000;
    410467    mark_invalid(start, size);
    … …  
    412469
    413470    /* add all static bound check values */
    414     p = (int *)&__bounds_start;
     471    p = (size_t *)&__bounds_start;
    415472    while (p[0] != 0) {
    416473        __bound_new_region((void *)p[0], p[1]);
    417474        p += 2;
    418475    }
     476
     477    dprintf(stderr, "%s, %s() end\n\n", __FILE__, __FUNCTION__);
     478}
     479
     480void __bound_main_arg(void **p)
     481{
     482    void *start = p;
     483    while (*p++);
     484
     485    dprintf(stderr, "%s, %s calling __bound_new_region(%p %x)\n",
     486            __FILE__, __FUNCTION__, start, (unsigned)((void *)p - start));
     487
     488    __bound_new_region(start, (void *) p - start);
    419489}
    420490
    421491void __bound_exit(void)
    422492{
     493    dprintf(stderr, "%s, %s()\n", __FILE__, __FUNCTION__);
    423494    restore_malloc_hooks();
    424495}
    425496
    426497static inline void add_region(BoundEntry *e,
    427                               unsigned long start, unsigned long size)
     498                              size_t start, size_t size)
    428499{
    429500    BoundEntry *e1;
    … …  
    445516
    446517/* create a new region. It should not already exist in the region list */
    447 void __bound_new_region(void *p, unsigned long size)
    448 {
    449     unsigned long start, end;
     518void __bound_new_region(void *p, size_t size)
     519{
     520    size_t start, end;
    450521    BoundEntry *page, *e, *e2;
    451     int t1_start, t1_end, i, t2_start, t2_end;
    452 
    453     start = (unsigned long)p;
     522    size_t t1_start, t1_end, i, t2_start, t2_end;
     523
     524    dprintf(stderr, "%s, %s(%p, %x) start\n",
     525        __FILE__, __FUNCTION__, p, (unsigned)size);
     526
     527    __bound_init();
     528
     529    start = (size_t)p;
    454530    end = start + size;
    455531    t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS);
    … …  
    462538    t2_end = (end >> (BOUND_T3_BITS - BOUND_E_BITS)) &
    463539        ((BOUND_T2_SIZE - 1) << BOUND_E_BITS);
    464 #ifdef BOUND_DEBUG
    465     printf("new %lx %lx %x %x %x %x\n",
    466            start, end, t1_start, t1_end, t2_start, t2_end);
    467 #endif
     540
    468541
    469542    e = (BoundEntry *)((char *)page + t2_start);
    … …  
    507580        add_region(e, start, size);
    508581    }
     582
     583    dprintf(stderr, "%s, %s end\n", __FILE__, __FUNCTION__);
    509584}
    510585
    511586/* delete a region */
    512 static inline void delete_region(BoundEntry *e,
    513                                  void *p, unsigned long empty_size)
    514 {
    515     unsigned long addr;
     587static inline void delete_region(BoundEntry *e, void *p, size_t empty_size)
     588{
     589    size_t addr;
    516590    BoundEntry *e1;
    517591
    518     addr = (unsigned long)p;
     592    addr = (size_t)p;
    519593    addr -= e->start;
    520594    if (addr <= e->size) {
    … …  
    540614            if (e == NULL)
    541615                break;
    542             addr = (unsigned long)p - e->start;
     616            addr = (size_t)p - e->start;
    543617            if (addr <= e->size) {
    544618                /* found: remove entry */
    … …  
    555629int __bound_delete_region(void *p)
    556630{
    557     unsigned long start, end, addr, size, empty_size;
     631    size_t start, end, addr, size, empty_size;
    558632    BoundEntry *page, *e, *e2;
    559     int t1_start, t1_end, t2_start, t2_end, i;
    560 
    561     start = (unsigned long)p;
     633    size_t t1_start, t1_end, t2_start, t2_end, i;
     634
     635    dprintf(stderr, "%s %s() start\n", __FILE__, __FUNCTION__);
     636
     637    __bound_init();
     638
     639    start = (size_t)p;
    562640    t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS);
    563641    t2_start = (start >> (BOUND_T3_BITS - BOUND_E_BITS)) &
    … …  
    571649        e = __bound_find_region(e, p);
    572650    /* test if invalid region */
    573     if (e->size == EMPTY_SIZE || (unsigned long)p != e->start)
     651    if (e->size == EMPTY_SIZE || (size_t)p != e->start)
    574652        return -1;
    575653    /* compute the size we put in invalid regions */
    … …  
    625703        delete_region(e, p, empty_size);
    626704    }
     705
     706    dprintf(stderr, "%s %s() end\n", __FILE__, __FUNCTION__);
     707
    627708    return 0;
    628709}
    629710
    630711/* return the size of the region starting at p, or EMPTY_SIZE if non
    631    existant region. */
    632 static unsigned long get_region_size(void *p)
    633 {
    634     unsigned long addr = (unsigned long)p;
     712   existent region. */
     713static size_t get_region_size(void *p)
     714{
     715    size_t addr = (size_t)p;
    635716    BoundEntry *e;
    636717
    … …  
    642723    if (addr > e->size)
    643724        e = __bound_find_region(e, p);
    644     if (e->start != (unsigned long)p)
     725    if (e->start != (size_t)p)
    645726        return EMPTY_SIZE;
    646727    return e->size;
    … …  
    710791    if (!ptr)
    711792        return NULL;
     793
     794    dprintf(stderr, "%s, %s calling __bound_new_region(%p, %x)\n",
     795           __FILE__, __FUNCTION__, ptr, (unsigned)size);
     796
    712797    __bound_new_region(ptr, size);
    713798    return ptr;
    … …  
    739824    if (!ptr)
    740825        return NULL;
     826
     827    dprintf(stderr, "%s, %s calling __bound_new_region(%p, %x)\n",
     828           __FILE__, __FUNCTION__, ptr, (unsigned)size);
     829
    741830    __bound_new_region(ptr, size);
    742831    return ptr;
    … …  
    756845{
    757846    void *ptr1;
    758     int old_size;
     847    size_t old_size;
    759848
    760849    if (size == 0) {
    … …  
    791880{
    792881    BoundEntry *page, *e;
    793     int i, j;
    794 
    795     printf("region dump:\n");
     882    size_t i, j;
     883
     884    fprintf(stderr, "region dump:\n");
    796885    for(i=0;i<BOUND_T1_SIZE;i++) {
    797886        page = __bound_t1[i];
    … …  
    800889            /* do not print invalid or empty entries */
    801890            if (e->size != EMPTY_SIZE && e->start != 0) {
    802                 printf("%08x:",
     891                fprintf(stderr, "%08x:",
    803892                       (i << (BOUND_T2_BITS + BOUND_T3_BITS)) +
    804893                       (j << BOUND_T3_BITS));
    805894                do {
    806                     printf(" %08lx:%08lx", e->start, e->start + e->size);
     895                    fprintf(stderr, " %08lx:%08lx", e->start, e->start + e->size);
    807896                    e = e->next;
    808897                } while (e != NULL);
    809                 printf("\n");
     898                fprintf(stderr, "\n");
    810899            }
    811900        }
    … …  
    821910    if (size == 0)
    822911        return;
    823     p = __bound_ptr_add((void *)p, size);
     912    p = __bound_ptr_add((void *)p, size - 1);
    824913    if (p == INVALID_POINTER)
    825914        bound_error("invalid pointer");
    … …  
    828917void *__bound_memcpy(void *dst, const void *src, size_t size)
    829918{
     919    void* p;
     920
     921    dprintf(stderr, "%s %s: start, dst=%p src=%p size=%x\n",
     922            __FILE__, __FUNCTION__, dst, src, (unsigned)size);
     923
    830924    __bound_check(dst, size);
    831925    __bound_check(src, size);
    … …  
    833927    if (src >= dst && src < dst + size)
    834928        bound_error("overlapping regions in memcpy()");
    835     return memcpy(dst, src, size);
     929
     930    p = memcpy(dst, src, size);
     931
     932    dprintf(stderr, "%s %s: end, p=%p\n", __FILE__, __FUNCTION__, p);
     933    return p;
    836934}
    837935
    … …  
    853951{
    854952    const char *p;
    855     int len;
     953    size_t len;
    856954
    857955    len = 0;
    … …  
    869967char *__bound_strcpy(char *dst, const char *src)
    870968{
    871     int len;
     969    size_t len;
     970    void *p;
     971
     972    dprintf(stderr, "%s %s: strcpy start, dst=%p src=%p\n",
     973            __FILE__, __FUNCTION__, dst, src);
    872974    len = __bound_strlen(src);
    873     return __bound_memcpy(dst, src, len + 1);
    874 }
    875 
     975    p = __bound_memcpy(dst, src, len + 1);
     976    dprintf(stderr, "%s %s: strcpy end, p = %p\n",
     977            __FILE__, __FUNCTION__, p);
     978    return p;
     979}
Note: See TracChangeset for help on using the changeset viewer.