| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| #include "testsuite.h" |
| |
| |
| #if 0 // __linux__ |
| Not yet. |
| #define _GNU_SOURCE |
| #include <dlfcn.h> |
| static char *find_symname(void *addr, char *buf); |
| #else |
| #define find_symname(a,b) "" |
| #endif |
| |
| #include <stdio.h> |
| #include <string.h> |
| |
| // given a full pathname, return path starting from test |
| static char *trim_fn(const char *ifn) |
| { |
| // basically find last /test/ |
| char *x, *fn = (char*) ifn; |
| char *rv = fn; |
| if (!strncmp(fn, "test/", 5)) |
| return fn; // fn starts with test/ |
| while ((x = strstr(rv, "/test/"))) // look for /test/ |
| rv = x+1; |
| return rv; |
| } |
| |
| #define TRUE 1 |
| #define FALSE 0 |
| int num_classes = 0, n_errors = 0, n_tests = 0; |
| int verbose = 0; |
| int test_finished = FALSE; |
| void f_check2(int actual, int expected, const char *name, const char *filename, int linenum) |
| { |
| n_tests++; |
| if (actual != expected) { |
| printf("ERROR at %s:%d '%s' actual %d != expected %d\n", trim_fn(filename), linenum, name, actual, expected); |
| n_errors++; |
| } else if (verbose > 1) { |
| printf("OK at %s:%d '%s' = %d\n", trim_fn(filename), linenum, name, actual); |
| } |
| } |
| |
| void f_check_field_offset(void* ps, void* pf, int ofst, const char *name, const char * filename, int linenum) |
| { |
| n_tests++; |
| if ((((char*)ps) + ofst) != ((char*)pf)) { |
| //printf("ERROR at %s:%d '%s' 0x%p + %d != 0x%p\n", trim_fn(filename), linenum, name, ps, ofst, pf); |
| printf("ERROR at %s:%d '%s' expected ofst %d != actual ofst %d\n", trim_fn(filename), linenum, |
| name, ofst, (int)(((char*) pf)-((char*) ps))); |
| n_errors++; |
| } else if (verbose > 1) { |
| printf("OK at %s:%d '%s' expected ofst = %d\n", trim_fn(filename), linenum, name, ofst); |
| } |
| } |
| |
| |
| static Class_Descriptor *cur_cd; |
| |
| static void *full_object_address; // address of the full object being constructed. |
| // This is used to do checks for ctors and dtors during the construction. |
| // if the object is being constructed via a placement new, we know the address before |
| // the ctors starts, else this is deduced from the first call to a ctor. |
| |
| static int cur_init_seq; |
| static int ctors_done; // set to 1 once the full object has been created. |
| |
| void |
| init_simple_test(const char *name) |
| { |
| num_classes++; |
| cur_cd = NULL; |
| if (verbose) |
| printf("Testing class %s\n", name); |
| } |
| |
| void |
| init_test(Class_Descriptor *cd, void *var_addr) |
| { |
| cur_cd = cd; |
| full_object_address = var_addr; |
| cur_init_seq = 0; |
| num_classes++; |
| ctors_done = 0; |
| if (verbose) |
| printf("Testing class %s\n", cd->name); |
| } |
| |
| #include <stdarg.h> |
| extern void abort(); |
| extern void exit(int); |
| static void Blow_Up(const char *m, ...) |
| { |
| va_list ap; |
| va_start(ap, m); |
| printf("Assertion Failed: "); |
| vprintf(m, ap); |
| printf("\n"); |
| exit(1); |
| } |
| |
| #define Is_True(a, b) if (!(a)) Blow_Up b |
| |
| static Base_Class * |
| find_base_from_seq_num(Class_Descriptor *cd, int seq) |
| { |
| Base_Class *b = cur_cd->bases; |
| if (b) { |
| for (; b->type; b++) |
| if (b->init_seq == seq) |
| return b; |
| } |
| return NULL; |
| } |
| |
| |
| static int satisfies_alternate_matches(VTBL_ENTRY expected, VTBL_ENTRY actual, |
| Class_Descriptor *cd, int t) |
| { |
| VTBL_ENTRY *alt_tbl = cd->alt_thunk_names; |
| int i=0, state = 0; |
| |
| if (!alt_tbl) return 0; |
| // alt_tbl is an array of items separated by a single NULL and terminated by another NULL |
| // each item is a sequence of VTBL entrie such that the first one is the expected value and |
| // rest of them are acceptable alternate values |
| // state machine: state 0 at the start. state 1 inside the list of extected. 2 inside other list |
| // state ANTERM expected actual any-non-NULL |
| // 0 F 1 F 2 |
| // 1 F F T 1 |
| // 2 0 2 2 2 |
| // |
| //printf(" SAM EXP:%p ACT:%p CD=%p tbl:%p t=%d\n", expected, actual, cd, alt_tbl, t); |
| while (1) { |
| VTBL_ENTRY v = alt_tbl[i]; |
| //printf(" [%d] %d= ", i, state); |
| //printf((v==NULL)?" 0\n":(v==ALT_NAMES_TERMINATOR)?" ALNT\n":":%p\n", v); |
| switch (state) { |
| case 0: |
| if (v == expected) |
| state = 1; |
| else if (v == actual || v == ALT_NAMES_TERMINATOR) |
| return FALSE; |
| else |
| state = 2; |
| break; |
| case 1: |
| if (v == actual) { |
| return TRUE; |
| } else if (v == ALT_NAMES_TERMINATOR || v == expected) { |
| return TRUE; // this allows tests to pass if the expected sym is a virtual thunk |
| // but the actual sym is not in the alternate lists. This can happen |
| // if there are multiple virtual thunks reaching same place, and |
| // some compiler selects a different one than our. For now we are |
| // allowing that. Perhaps we can figure out a way of tightening this |
| // by |
| // - adding all possible thunks that reach same place, |
| // - somehow comparing thunks for equivalence |
| //return FALSE; |
| } else |
| state = 1; |
| break; |
| case 2: |
| state = (v == ALT_NAMES_TERMINATOR) ? 0 : 2; |
| } |
| i++; |
| } |
| } |
| |
| |
| // actual points to the VTT variable defined by the compiler under test. |
| // expected points to an array of VTT_ENTRY structures. Each VTT_ENTRY structure has a |
| // field 'VTBL_ENTRY *vtbl', which must match the corresponding entry of actual. However, |
| // the meaning of the match is non-trivial. If expected[i].ofst==0, actual[i] and expected[i].vtbl |
| // both must point to same element of the primary vtbl of the class, hence the pointer values |
| // must match. if expected[i].ofst is non-zero, both point to copies of secondary vtables whose |
| // contents must be same. In that case, we run memcmp on those vtables. |
| static void |
| check_vtt_tbl(Class_Descriptor *cd, VTT_ENTRY *expected, VTBL_ENTRY **actual, char *name, int size) |
| { |
| int i, j; |
| n_tests++; |
| if (verbose > 1) |
| printf("check_vtt_tbl %s %s EXPECTED:%p ACTUAL:%p %d\n", cd->name, name, expected, actual, size); |
| for (i=0; i<size; i++) { |
| if (expected[i].vtbl != actual[i]) { |
| // actual pointers do not match, but the contents could still match. |
| int ofst = expected[i].ofst; |
| int size = expected[i].size; |
| VTBL_ENTRY *exp = expected[i].vtbl - ofst; |
| VTBL_ENTRY *act = actual[i] - ofst; |
| int n_mismatches = 0; |
| if (memcmp(exp, act, size*sizeof(VTBL_ENTRY)) == 0) { |
| // contents match. |
| continue; |
| } |
| for (j=0; j<size; j++) { |
| if (exp[j] != act[j] && !satisfies_alternate_matches(exp[j], act[j], cd, j)) { |
| if (n_mismatches==0) { |
| static char erb1[10240], erb2[10240]; |
| if (act[j] == NULL) { |
| continue; // a vtbl entry can be NULL in clang, if clang chooses to always use another vtbl |
| } |
| printf("ERROR: Expected contents of %s::vtbl from vtt, for class %s do not match. at index %d. " |
| "memcmp(EXPECTED:%p,ACTUAL:%p,%d)\n", |
| name, cd->name, j, exp, act, (int)(size*sizeof(VTBL_ENTRY))); |
| n_mismatches++; |
| n_errors++; |
| printf(" %d: EXPECTED:%p%s ACTUAL:%p%s\n", j, |
| (void*)exp[j], find_symname((void*)exp[j], erb1), |
| (void*)act[j], find_symname((void*)act[j], erb2)); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| static void |
| check_vftbl(Class_Descriptor *cd, void *expected, void *actual, char *name, int size) |
| { |
| int i, n_mismatches=0; |
| n_tests++; |
| if (verbose > 1) |
| printf("check_vftbl %s %s %p %p %d\n", cd->name, name, expected, actual, size); |
| if (memcmp(expected, actual, sizeof(VTBL_ENTRY)*size)) { |
| void **pexp = (void**) expected; |
| void **pact = (void**) actual; |
| for (i=0; i<size; i++) { |
| if (pexp[i] != pact[i] && |
| !satisfies_alternate_matches((VTBL_ENTRY)pexp[i], (VTBL_ENTRY)pact[i], cd, -i)) { |
| static char erb1[10240], erb2[10240]; |
| if (pact[i] == NULL) { |
| continue; // a vtbl entry can be NULL in clang, if clang chooses to always use another vtbl |
| } |
| |
| if (n_mismatches==0) { |
| printf("ERROR: Expected contents of %s::vtbl, for class %s do not match.\n", name, cd->name); |
| n_errors++; |
| n_mismatches++; |
| } |
| printf(" %d: EXPECTED:%p%s ACTUAL:%p%s\n", i, pexp[i], find_symname(pexp[i], erb1), |
| pact[i], find_symname(pact[i], erb2)); |
| } |
| } |
| } |
| } |
| |
| // if derivation of b in cd has any virtual steps, return he most-derived such base, else |
| // return NULL |
| static Base_Class * |
| any_virtual_steps_in_derivation(Class_Descriptor *cd, Base_Class *b) |
| { |
| // first a simple assertion check that b is a base class of cd |
| Is_True( |
| cd->bases && // cd has bases |
| (b >= cd->bases) && ((b-cd->bases) < cd->n_bases) && // b lies between first and last base of cd |
| ((cd->bases + (b-cd->bases)) == b), // it is a proper Base_Class ptr |
| ("Wrong base in any_virtual...")); |
| while (1) { |
| if (b->is_virtual) |
| return b; |
| if (b->parent_idx < 0) |
| return 0; |
| b = cd->bases + b->parent_idx; |
| } |
| } |
| |
| // check tbls of cd and all non-virtual bases, and, if check_virtual_bases is TRUE, its |
| // virtual bases as well. This flag will be true when the var_ptr points to a full object of |
| // type cd, i.e., |
| // - when the cd is the main class under test and the full object of cd has been constructed, |
| // and destruction has not yet started, |
| // - or, if cd is a base class of the class under test, but cd itself does not have any |
| // virtual base classes and we are currently in ctor or dtor of cd. |
| static void |
| check_full_object_vtbls(void *var_ptr, Class_Descriptor *cd, int check_virtual_bases) |
| { |
| Base_Class *b; |
| // check that the initialized contents of the main vtbl variable, as generated by the |
| // compiler-under-test are what we expect them to be |
| if (cd->expected_vtbl_contents) { |
| check_vftbl(cd, cd->expected_vtbl_contents, cd->vtbl.var, cd->vtbl.name, cd->vtbl_size); |
| // check that the fully initialized object attaches to that vtbl variable at correct |
| // offset. i.e., var_ptr[0] should point inside the vtbl_var+vtbl_ofst. |
| // However, if var_ptr is does not point to a full object of cd (indicated by |
| // check_virtual_bases being false), and cd has some virtual bases, its vtbl will not match |
| // the cd->vtbl_var because that reflects the shape of a full object of cd. |
| if (check_virtual_bases || !cd->has_virtual_bases) { |
| if ((*(VTBL_ENTRY**)var_ptr) != (cd->vtbl.var + cd->vtbl_ofst)) { |
| printf("ERROR: Object of class %s::%s does not point to expected spot in vtbl\n", cur_cd->name, cd->name); |
| n_errors++; |
| } |
| } |
| } |
| // check that any non-primary base classes also attach to the expected offsets |
| if (cd->bases) |
| for (b=cd->bases; b->type; b++) { |
| if (b->ofst != 0 && b->vtbl_ofst >= 0 && (check_virtual_bases || !any_virtual_steps_in_derivation(cd, b))) { |
| // cd->vtbl.var is the vbl variable. It contains the main vtbl, followed by vtbls |
| // for base classes at non-zero offsets. b->vtbl_ofst is the offset (in terms of vtbl |
| // entries) of the b's vtbl in the main vtbl. But the object does not attach to the top |
| // of any vtbl; it attaches at least two entries down, and maybe more. That is given by |
| // b->num_negative_vtbl_entries |
| if ((*(VTBL_ENTRY**)(b->ofst+(char*)var_ptr)) != |
| (cd->vtbl.var + (b->vtbl_ofst+b->num_negative_vtbl_entries))) { |
| printf("ERROR: base class %s of class %s::%s does not have correct vtbl ", b->type->name, |
| cur_cd->name, cd->name); |
| printf("0x%x != (0x%x + %d + %d) = 0x%x\n", |
| (int)(*(VTBL_ENTRY**)(b->ofst+(char*)var_ptr)) , |
| (int)cd->vtbl.var ,(int) b->num_negative_vtbl_entries, (int)b->vtbl_ofst, |
| (int)(cd->vtbl.var + (b->vtbl_ofst+b->num_negative_vtbl_entries))); |
| n_errors++; |
| } |
| } |
| } |
| } |
| |
| |
| |
| // Given a derived class der, and it base class entry b. d_in_b is a Base_Class entry in |
| // b->type. Find corresponding Base_Class entry of der. |
| // There are three possible situations: |
| // 1) d_in_b is virtual by itself. In that case we need to just find a virtual base class of same |
| // type in der. Since there can be only one such virtual base class in der, that is all. |
| // 2) d_in_b is not virtual, and there are no virtual steps from b to d_in_b. In this case |
| // the relative offset of b-to-d_in_b will be same in der as it is in a b. So we just look |
| // for a base class of expected type at such computed offset. |
| // 3) Third case is more complicated. here d_in_b is not virtual by itself, but there are virtual |
| // steps in b-to-d_in_b derivation. Say a base class t is lowest such step, i.e., t is a |
| // virtual base of b, and d_in_b is a base class of t without any virtual steps from t to |
| // d_in_b. In this case we first find the virtual base t in der using rule 1, and then use |
| // rule 2 to find the final answer |
| // |
| static Base_Class * |
| find_corresp_base(Class_Descriptor *der, Base_Class *b, Base_Class *d_in_b) |
| { |
| Base_Class *t, *p, *q; |
| |
| if (d_in_b->is_virtual) { |
| // case 1 |
| for (t = der->bases; t < (der->bases + der->n_bases); t++) |
| if (t->is_virtual && t->type == d_in_b->type) |
| return t; |
| Is_True(0, ("Count not find virtual base class %s in %s", d_in_b->type->name, der->name)); |
| } |
| if (!(p=any_virtual_steps_in_derivation(b->type, d_in_b))) { |
| // case 2 |
| for (t = der->bases; t < (der->bases + der->n_bases); t++) |
| if ((!t->is_virtual) && t->ofst == (b->ofst + d_in_b->ofst) && t->type == d_in_b->type ) |
| return t; |
| Is_True(0, ("Count not find non virtual base class %s in %s", d_in_b->type->name, der->name)); |
| } |
| |
| // case 3. First we find the highest non-virtual derived class from d_in_b |
| q = find_corresp_base(der, b, p);// use rule 1. This will work because we know that p is virtual |
| for (t = der->bases; t < (der->bases + der->n_bases); t++) |
| if ((!t->is_virtual) && t->ofst == (q->ofst + d_in_b->ofst-p->ofst) && t->type == d_in_b->type ) |
| return t; |
| Is_True(t<(der->bases + der->n_bases), ("Could not find_corresp_base(%s, %s, %s)", der->name, |
| b->type->name, d_in_b->type->name)); |
| return 0; |
| } |
| |
| // same as strcat, but some toolkits do not have strcat |
| static void |
| mystrcat(char *a, char *b) |
| { |
| int i, j; |
| for (j=0; a[j]; j++) ; |
| for (i=0; b[i]; i++) a[j++] = b[i]; |
| a[j] = 0; |
| } |
| |
| // Called from ctor and dtors of base classes of the main class under test (which is cur_cd). |
| // init_seq is the sequence number of ctors, which increases from 1 till the whole class has |
| // been contructed, and decreases back. n is the name of the baseclass whose ctor/dtor has |
| // been called. this_p is the 'this' pointer being pass the ctor/dtor. The task here is to check |
| // that correct vtbls are being passed to the current class being constructed, and all its |
| // base classes. |
| void |
| check_base(int init_seq, const char *n, void* this_p, const char *filename, int linenum) |
| { |
| Base_Class *b; |
| if (verbose> 1) |
| printf("check_%ctor %s %p-%p from %s:%d cur_cd=%s init_seq=%d cur_init_seq=%d\n", |
| ctors_done?'d':'c', |
| n, this_p, full_object_address, trim_fn(filename), linenum, cur_cd->name, init_seq, cur_init_seq); |
| if (init_seq == 1 && !full_object_address) { |
| // this is first call. Go through base classes of cur_cd to find the base with |
| // init_seq==1, and deduce the full object address from that. |
| b = find_base_from_seq_num(cur_cd, 1); |
| Is_True(b, ("first-init base not found")); |
| full_object_address = (void*) (((char*)this_p) - b->ofst); |
| } else { |
| // find the base with this init seq |
| b = find_base_from_seq_num(cur_cd, init_seq); |
| Is_True(b, ("init base %s %d not found", cur_cd->name, init_seq)); |
| } |
| if (strcmp(b->type->name, n)) { |
| printf("Wrong ctor/dtor being called \n"); |
| n_errors++; |
| return; |
| } |
| if (full_object_address != (void*) (((char*)this_p) - b->ofst)) { |
| printf("ERROR: %ctor of %s::%s being called with wrong offset 0x%p != 0x%p+%d = 0x%p\n", |
| ctors_done?'d':'c', cur_cd->name, b->type->name, |
| this_p, full_object_address, (int)b->ofst, |
| ((char*)full_object_address)+b->ofst); |
| n_errors++; |
| return; |
| } |
| if (!cur_cd->vtbl.var) |
| return; // nothing further to check. |
| // While construction a full object A, during construction or destruction of a subobject, |
| // say B, the virtual function set of A::B must be same as the full object B, irrespective of |
| // any virtual function overrides between B and A. However, the shape of A::B is not necessarily |
| // same of the full object B. |
| if (!b->type->has_virtual_bases) { |
| // The shape of A::B is same as the full object B, since B does not have any virtual bases. |
| // In that case, we can just run the full_object test. |
| check_full_object_vtbls(this_p, b->type, TRUE); |
| } else { |
| // b->type has some virtual bases of its own. So the shape is not same as that of a full |
| // b->type, but the virtual function set is. In this case check the primary vtbl, and |
| // each base class separately. |
| // We are running ctor of B, while constructing full object A |
| // First, the primary vtbl test. |
| // a) if b->type_subarray_index_in_vtt is non-zero, the primary vtable is A.vtt[b.index_in_vtbl-1] |
| // b) else find the lowest parent, D, of B whose Base_Class entry for class B has a non-zero |
| // index_in_vtt. (this is a_base_class.index_in_construction_vtable_array). There |
| // must be one. |
| // c) proceed up from D to A, collecting |
| // (base_subarray_index_in_vtt-1) whereever base_subarray_index.. is non-zero, and |
| // add that to the number of the last step. |
| VTBL_ENTRY *pointed_tbl = *(VTBL_ENTRY**)this_p; |
| VTT_ENTRY *vttp; |
| Base_Class *d_in_b, *d_in_cur_cd; |
| Class_Descriptor *bc = b->type; |
| //check_full_object_vtbls(this_p, b->type, FALSE); // check non-virtual base classes, if any |
| Is_True(b->base_subarray_index_in_vtt>0, ("%s::%s->type_subarray_index_in_vtt must be >0", |
| cur_cd->name, bc->name)); |
| vttp = cur_cd->expected_vtt_contents + (b->base_subarray_index_in_vtt-1); |
| check_vftbl(cur_cd, vttp->vtbl - vttp->ofst, pointed_tbl-vttp->ofst, b->type->name, vttp->size); |
| // and now we need to check vtbls of all subclasses of b that use vtbl. |
| // scan all base classes of B, and find corresponding Base_Class entry in cur_cd->bases |
| for (d_in_b = bc->bases; d_in_b < (bc->bases+bc->n_bases); d_in_b++) { |
| char buf[10240]; |
| if (!d_in_b->type->vtbl.var) |
| continue; // nothing to check for this base |
| if (d_in_b->index_in_vtt == 0) |
| continue; // checked via some other base |
| d_in_cur_cd = find_corresp_base(cur_cd, b, d_in_b); |
| if (d_in_b->ofst == 0) |
| continue; // d is at offset 0, so the vtbl has already been checked above. |
| // we need to take the offset from d_in_cur_cd, because that reflects the shape of cur_cd |
| // but we take expected vtbl ptr by first selecting vtt group for b-in-cur_cd and then |
| // using d-in-b to pick a particular vtbl |
| vttp = cur_cd->expected_vtt_contents + (b->base_subarray_index_in_vtt-1) + (d_in_b->index_in_vtt-1); |
| pointed_tbl = *(VTBL_ENTRY**)(((long)full_object_address) + d_in_cur_cd->ofst); |
| |
| // follwing four lines are essentially |
| // sprintf(buf, "%s-during-%s()", d_in_b->type->name, bc->name); |
| buf[0] = 0; |
| mystrcat(buf, d_in_b->type->name); |
| mystrcat(buf, "-during-"); |
| mystrcat(buf, bc->name); |
| mystrcat(buf, "()"); |
| check_vftbl(cur_cd, vttp->vtbl - vttp->ofst, pointed_tbl-vttp->ofst, buf, vttp->size); |
| } |
| } |
| } |
| |
| static Base_Class *find_base_class(ptrdiff_t ofst, Class_Descriptor *cd, const char *name) |
| { |
| Base_Class *bc = cd->bases; |
| if (bc) { |
| for (; bc < (cd->bases+cd->n_bases); bc++) |
| if (bc->ofst == ofst && !strcmp(bc->type->name, name)) |
| return bc; |
| } |
| return NULL; |
| } |
| |
| void |
| f_note_ctor(const char *n, void* this_p, const char *filename, int linenum) |
| { |
| if (cur_cd == NULL) // cur_cd has no base classes. This must be from a field |
| return; |
| if (!cur_cd->has_class_type_fields) { |
| if (strcmp(n, cur_cd->name)) |
| check_base(++cur_init_seq, n, this_p, filename, linenum); |
| // else we have reached the ctor of the top class. The tests will be done by test_class_info |
| } else if (cur_cd->n_bases == 0) { |
| // nothing to check. ctor is for a field. |
| } else { |
| // cur_cd has fields that will call constructors and destructors, therefore init_sequence |
| // checks can not be done, but it also has bases that need to be checked. |
| // See if a base matches the offset and type, and check that |
| Base_Class *bc = find_base_class(((char*)this_p) - ((char*)full_object_address), cur_cd, n); |
| if (bc) |
| check_base(bc->init_seq, n, this_p, filename, linenum); |
| } |
| } |
| |
| void |
| f_note_dtor(const char *n, void * this_p, const char *filename, int linenum) |
| { |
| if (test_finished) |
| return; |
| if (cur_cd == NULL) // cur_cd has no base classes. This must be from a field |
| return; |
| if (!cur_cd->has_class_type_fields) { |
| if (strcmp(n, cur_cd->name)) |
| check_base(cur_init_seq--, n, this_p, filename, linenum); |
| // else we are destroying the top class. The tests have been done by test_class_info |
| } else if (cur_cd->n_bases == 0) { |
| // nothing to check. dtor is for a field. |
| } else { |
| // cur_cd has fields that will call constructors and destructors, therefore init_sequence |
| // checks can not be done, but it also has bases that need to be checked. |
| // See if a base matches the offset and type, and check that |
| Base_Class *bc = find_base_class(((char*)this_p) - ((char*)full_object_address), cur_cd, n); |
| if (bc) |
| check_base(bc->init_seq, n, this_p, filename, linenum); |
| } |
| } |
| |
| void Check_Ctor_Dtor_Calls(void *op) |
| { |
| if (cur_init_seq != 0) { |
| printf("ERROR: Expected number of dtors not called %s\n", cur_cd->name); |
| n_errors++; |
| } |
| } |
| |
| |
| void test_class_info(void *var_ptr, Class_Descriptor* cd) |
| { |
| ctors_done = 1; |
| if (verbose > 1) { |
| printf("test_class_info %s %p cur_init_seq=%d\n", cd->name, var_ptr, cur_init_seq); |
| } |
| if (full_object_address && full_object_address != var_ptr) { |
| printf("ERROR: full object address does not match deduced address %s\n", cur_cd->name); |
| n_errors++; |
| } |
| if ((cur_init_seq != cd->n_initialized_bases) && !cd->has_class_type_fields) { |
| printf("ERROR: Not all bases of %s were initialized \n", cur_cd->name); |
| n_errors++; |
| } |
| if (cd->expected_vtbl_contents) { |
| // check that fully constructed object points to correct vtbls. |
| check_full_object_vtbls(var_ptr, cd, TRUE); |
| } |
| if (!cd->vtt.var) { |
| // Sunil: may 1, 2014: Made vtt a weak symbol and added '&&cd->vtt.var' check. Clang, with -O |
| // does not generate VTT if it is not going to be used, such as if a class X has virtual base |
| // Y but Y has no virtual base of functions. In this case the VTT for X will never be used. |
| // TODO: add check for that property; that base classes do not need vtt. |
| } else if (cd->expected_vtt_contents) { |
| // We can not simply compare the contents of VTT tables always. |
| // VTT table has two kind of entries. Some entries point to elements of main vtbl whose |
| // name is specified by the ABI spec, so we refer to them as globally visible name, and |
| // we can expec the pointer values in vtt to be same. |
| // In other cases though, vtt entries point to aux-vtables, whose names are not specified |
| // by the ABI spec, so the generated tests have their own names which are not same as the |
| // names generated by the compiler-under-test. Their contents are expected to match, but |
| // not the pointer values. The contents are being tested by the ctor vtable tests. |
| // TODO: check those vtt entries here that point to main vtbl |
| check_vtt_tbl(cd, cd->expected_vtt_contents, cd->vtt.var, cd->vtt.name, cd->vtt_size); |
| } |
| } |
| |
| static int f_isLittleEndian() { |
| unsigned short i = 0xff00; |
| unsigned char *i_ptr = (unsigned char *) &i; |
| return !(*i_ptr); |
| } |
| static int isLittleEndian; |
| |
| static unsigned char LITTLE_ENDIAN_MASKS[] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff }; |
| static unsigned char BIG_ENDIAN_MASKS[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff }; |
| |
| // Function to read the value of a bitfield |
| // NOTE: This function implicitly depends on a byte having 8 bits. If a byte is of a different size, several of the calculations would be incorrect. |
| static long long readValue(unsigned char *iter, unsigned int bit_offset, int size) { |
| int is_little_endian = isLittleEndian; |
| long long retval = 0; |
| unsigned char mask = 0; |
| unsigned char adjustment_offset = 0; |
| |
| if(!iter) return retval; |
| |
| // read the first partial piece (if any) |
| if(bit_offset) { |
| unsigned char bits_to_read = 8 - bit_offset; |
| // Check to see if the object is fully contained within the remaining bits, and if so |
| // restrict the read to only those bits. |
| if(size < bits_to_read) |
| bits_to_read = size; |
| |
| if(is_little_endian) { |
| mask = LITTLE_ENDIAN_MASKS[bits_to_read] << bit_offset; |
| retval = ((*iter) & mask) >> bit_offset; |
| adjustment_offset += bits_to_read; |
| } else { |
| mask = BIG_ENDIAN_MASKS[bits_to_read] >> bit_offset; |
| retval = (*iter) & mask; |
| // If we read in the entire value, we need to potentially right shift it, and clear |
| // out the upper bits to be safe |
| if(size == bits_to_read) { |
| retval >>= (8 - (bits_to_read + bit_offset)); |
| retval &= ~(BIG_ENDIAN_MASKS[8 - bits_to_read]); |
| } |
| } |
| |
| // Decrement the size by the number of bits read, and move to the next byte |
| size -= bits_to_read; |
| iter++; |
| } |
| |
| // read in a full byte at a time |
| while(size >= 8) { |
| if(is_little_endian) { |
| retval |= ((long long)((*iter) & 0xff)) << adjustment_offset; |
| adjustment_offset += 8; |
| } else { |
| retval <<= 8; |
| retval |= (*iter) & 0xff; |
| } |
| // Decrement the size by a byte and move to the next byte |
| size -= 8; |
| iter++; |
| } |
| |
| // read any remaining bits |
| if(size) { |
| if(is_little_endian) { |
| mask = LITTLE_ENDIAN_MASKS[size]; |
| retval |= ((long long)((*iter) & mask)) << adjustment_offset; |
| adjustment_offset += size; |
| } else { |
| mask = BIG_ENDIAN_MASKS[size]; |
| retval <<= size; |
| retval |= ((*iter) & mask) >> (8 - size); |
| } |
| size = 0; |
| iter = 0; |
| } |
| |
| return retval; |
| } |
| |
| |
| int is_bitfield_value_correct(void *obj_ptr, unsigned int byte_offset, unsigned int bit_offset, unsigned int size, long long expected_value) { |
| long long read_value = readValue(((unsigned char *)obj_ptr) + byte_offset, bit_offset, size); |
| unsigned long long expected_mask = 0, i; |
| |
| //n_tests++; |
| |
| // Calculate the mask to be used for the incoming value which was probably sign extended |
| expected_mask = 0; |
| for(i = 0; i < size; i += 8) { |
| expected_mask <<= 8; |
| expected_mask |= 0xff; |
| } |
| if(size % 8) { |
| expected_mask <<= (size % 8); |
| expected_mask |= LITTLE_ENDIAN_MASKS[(size % 8)]; |
| } |
| expected_value &= expected_mask; |
| read_value &= expected_mask; |
| |
| if(read_value != expected_value) |
| return 0; |
| |
| return 1; |
| } |
| void clear_var(void *a, unsigned b) |
| { |
| // do not rely on memzero |
| char *ca = a; |
| unsigned i; |
| for (i=0; i<b; i++) |
| ca[i] = 0; |
| } |
| |
| |
| |
| void test_bitfield_value(void *obj_ptr, unsigned int byte_offset, unsigned int bit_offset, |
| unsigned int size, long long expected_value, unsigned var_size, |
| const char *name, const char *filename, int linenum) { |
| long long read_value = readValue(((unsigned char *)obj_ptr) + byte_offset, bit_offset, size); |
| unsigned long long expected_mask = 0, i; |
| |
| n_tests++; |
| |
| // Calculate the mask to be used for the incoming value which was probably sign extended |
| expected_mask = 0; |
| if (size > 7) |
| for(i = 0; i < size; i += 8) { |
| expected_mask <<= 8; |
| expected_mask |= 0xff; |
| } |
| if(size % 8) { |
| expected_mask <<= (size % 8); |
| expected_mask |= LITTLE_ENDIAN_MASKS[(size % 8)]; |
| } |
| expected_value &= expected_mask; |
| read_value &= expected_mask; |
| |
| if(read_value != expected_value) { |
| int i, found = -1; |
| for (i=1; i<20; i++) { |
| if ((byte_offset+i) < var_size && is_bitfield_value_correct(obj_ptr, byte_offset+i, bit_offset, size, expected_value)) { |
| found = byte_offset+i; |
| break; |
| } |
| if (byte_offset >= i && is_bitfield_value_correct(obj_ptr, byte_offset-i, bit_offset, size, expected_value)) { |
| found = byte_offset-i; |
| break; |
| } |
| } |
| printf("ERROR at %s:%d Bitfield errors found (expected=0X%llX, got=0X%llX) in %s", |
| trim_fn(filename), linenum, expected_value, read_value, name); |
| if (found >= 0) printf(" expected byte ofst %d != actual byte ofst %d", byte_offset, found); |
| printf("\n"); |
| n_errors++; |
| } |
| |
| return; |
| } |
| |
| |
| ATCM *atcm_head; |
| |
| #ifndef __cplusplus |
| extern void *malloc(size_t); |
| void atc_register(voidfunc func, const char *name, size_t sz) |
| { |
| ATCM *sa = (ATCM*) malloc(sizeof(ATCM)); |
| sa->next = atcm_head; |
| atcm_head = sa; |
| sa->func = func; |
| sa->name = name; |
| } |
| |
| #endif |
| |
| |
| int main(int argc, char **argv) |
| { |
| int i, run_full_test = 1; |
| ATCM *p; |
| isLittleEndian = f_isLittleEndian(); |
| for (i=1; i<argc; i++) { |
| char *a = argv[i]; |
| if (a[0] == '-' && a[1] == 'v') { |
| verbose++; |
| continue; |
| } |
| for (p=atcm_head; p; p = p->next) |
| if (strcmp(a, p->name)==0) |
| break; |
| if (!p) { |
| printf("Unknown arg '%s'\n", a); |
| exit(1); |
| } |
| p->func(); |
| run_full_test = 0; |
| } |
| if (run_full_test) { |
| ATCM *t, *h = NULL; |
| // first reverse the chain |
| while (atcm_head) { |
| t = atcm_head; |
| atcm_head = t->next; |
| t->next = h; |
| h = t; |
| } |
| |
| while (h) { |
| h->func(); |
| h = h->next; |
| } |
| } |
| printf("TEST %s. %d classes. %d tests. %d failures.\n", |
| n_errors||!n_tests?"FAILED":"PASSED",num_classes, n_tests, n_errors); |
| |
| test_finished = TRUE; |
| cur_cd = NULL; |
| return n_errors != 0; |
| } |
| |
| long long hide_sll(long long p) { return p; } |
| unsigned long long hide_ull(unsigned long long p) { return p; } |
| #if 0 //def __linux__ |
| static char *find_symname(void *addr, char *buf) |
| { |
| Dl_info dli; |
| int rv; |
| if (!addr) return ""; |
| rv = dladdr(addr, &dli); |
| if (rv) return ""; |
| long ofst = ((long)dli.dli_saddr) - ((long)addr); |
| if (ofst > 0) |
| sprintf(buf, " (%s+%ld)", dli.dli_sname, ofst); |
| else if (ofst < 0) |
| sprintf(buf, " (%s-%ld)", dli.dli_sname, -ofst); |
| else |
| sprintf(buf, " (%s)", dli.dli_sname); |
| return buf; |
| } |
| #endif |