void save_classes( void ) { CLASS_TYPE *cclass; for ( cclass = class_first; cclass; cclass = cclass->next ) save_class( cclass ); return; }
tid_t add_class(tid_t tid_of_struc) { //classes are built on top of structures, make sure there is one before continuing if(!get_struc(tid_of_struc)) return BADNODE; if(get_class(tid_of_struc)) { return tid_of_struc; } class_t clas; clas.flags = 0; clas.tid = tid_of_struc; clas.functions_ea.clear(); clas.parents_tid.clear(); clas.virt_table_ea = BADADDR; save_class(&clas); //DONE: add to classes index add_class_at_idx(tid_of_struc, BADNODE); return tid_of_struc; }
/* * Lazy initialization of class descriptor. */ void pmix_class_initialize(pmix_class_t *cls) { pmix_class_t *c; pmix_construct_t* cls_construct_array; pmix_destruct_t* cls_destruct_array; int cls_construct_array_count; int cls_destruct_array_count; int i; assert(cls); /* Check to see if anyone initialized this class before we got a chance to */ if (1 == cls->cls_initialized) { return; } /* * First calculate depth of class hierarchy * And the number of constructors and destructors */ cls->cls_depth = 0; cls_construct_array_count = 0; cls_destruct_array_count = 0; for (c = cls; c; c = c->cls_parent) { if( NULL != c->cls_construct ) { cls_construct_array_count++; } if( NULL != c->cls_destruct ) { cls_destruct_array_count++; } cls->cls_depth++; } /* * Allocate arrays for hierarchy of constructors and destructors * plus for each a NULL-sentinel */ cls->cls_construct_array = (void (**)(pmix_object_t*))malloc((cls_construct_array_count + cls_destruct_array_count + 2) * sizeof(pmix_construct_t) ); if (NULL == cls->cls_construct_array) { perror("Out of memory"); exit(-1); } cls->cls_destruct_array = cls->cls_construct_array + cls_construct_array_count + 1; /* * The constructor array is reversed, so start at the end */ cls_construct_array = cls->cls_construct_array + cls_construct_array_count; cls_destruct_array = cls->cls_destruct_array; c = cls; *cls_construct_array = NULL; /* end marker for the constructors */ for (i = 0; i < cls->cls_depth; i++) { if( NULL != c->cls_construct ) { --cls_construct_array; *cls_construct_array = c->cls_construct; } if( NULL != c->cls_destruct ) { *cls_destruct_array = c->cls_destruct; cls_destruct_array++; } c = c->cls_parent; } *cls_destruct_array = NULL; /* end marker for the destructors */ cls->cls_initialized = 1; save_class(cls); /* All done */ }
/* * Lazy initialization of class descriptor. */ void opal_class_initialize(opal_class_t *cls) { opal_class_t *c; opal_construct_t* cls_construct_array; opal_destruct_t* cls_destruct_array; int cls_construct_array_count; int cls_destruct_array_count; int i; assert(cls); /* Check to see if any other thread got in here and initialized this class before we got a chance to */ if (1 == cls->cls_initialized) { return; } opal_atomic_lock(&class_lock); /* If another thread initializing this same class came in at roughly the same time, it may have gotten the lock and initialized. So check again. */ if (1 == cls->cls_initialized) { opal_atomic_unlock(&class_lock); return; } /* * First calculate depth of class hierarchy * And the number of constructors and destructors */ cls->cls_depth = 0; cls_construct_array_count = 0; cls_destruct_array_count = 0; for (c = cls; c; c = c->cls_parent) { if( NULL != c->cls_construct ) { cls_construct_array_count++; } if( NULL != c->cls_destruct ) { cls_destruct_array_count++; } cls->cls_depth++; } /* * Allocate arrays for hierarchy of constructors and destructors * plus for each a NULL-sentinel */ cls->cls_construct_array = (void (**)(opal_object_t*))malloc((cls_construct_array_count + cls_destruct_array_count + 2) * sizeof(opal_construct_t) ); if (NULL == cls->cls_construct_array) { perror("Out of memory"); exit(-1); } cls->cls_destruct_array = cls->cls_construct_array + cls_construct_array_count + 1; /* * The constructor array is reversed, so start at the end */ cls_construct_array = cls->cls_construct_array + cls_construct_array_count; cls_destruct_array = cls->cls_destruct_array; c = cls; *cls_construct_array = NULL; /* end marker for the constructors */ for (i = 0; i < cls->cls_depth; i++) { if( NULL != c->cls_construct ) { --cls_construct_array; *cls_construct_array = c->cls_construct; } if( NULL != c->cls_destruct ) { *cls_destruct_array = c->cls_destruct; cls_destruct_array++; } c = c->cls_parent; } *cls_destruct_array = NULL; /* end marker for the destructors */ cls->cls_initialized = 1; save_class(cls); /* All done */ opal_atomic_unlock(&class_lock); }