static jl_sym_t *mk_symbol(const char *str, size_t len)
{
jl_sym_t *sym;
size_t nb = symbol_nbytes(len);
if (nb >= SYM_POOL_SIZE) {
jl_exceptionf(jl_argumenterror_type, "Symbol length exceeds maximum length");
}
jl_taggedvalue_t *tag;
#ifdef MEMDEBUG
tag = (jl_taggedvalue_t*)malloc(nb);
#else
static char *sym_pool = NULL;
static char *pool_ptr = NULL;
if (sym_pool == NULL || pool_ptr+nb > sym_pool+SYM_POOL_SIZE) {
sym_pool = (char*)malloc(SYM_POOL_SIZE);
pool_ptr = sym_pool;
}
tag = (jl_taggedvalue_t*)pool_ptr;
pool_ptr += nb;
#endif
sym = (jl_sym_t*)jl_valueof(tag);
// set to old marked since we don't need write barrier on it.
tag->header = ((uintptr_t)jl_sym_type) | GC_OLD_MARKED;
sym->left = sym->right = NULL;
sym->hash = hash_symbol(str, len);
memcpy(jl_symbol_name(sym), str, len);
jl_symbol_name(sym)[len] = 0;
return sym;
}
static jl_sym_t *symtab_lookup(jl_sym_t *volatile *ptree, const char *str,
size_t len, jl_sym_t *volatile **slot)
{
jl_sym_t *node = jl_atomic_load_acquire(ptree);
uintptr_t h = hash_symbol(str, len);
// Tree nodes sorted by major key of (int(hash)) and minor key of (str).
while (node != NULL) {
intptr_t x = (intptr_t)(h - node->hash);
if (x == 0) {
x = strncmp(str, jl_symbol_name(node), len);
if (x == 0 && jl_symbol_name(node)[len] == 0) {
if (slot != NULL)
*slot = ptree;
return node;
}
}
if (x < 0)
ptree = &node->left;
else
ptree = &node->right;
node = jl_atomic_load_acquire(ptree);
}
if (slot != NULL)
*slot = ptree;
return node;
}
static jl_sym_t *mk_symbol(const char *str, size_t len)
{
#ifndef MEMDEBUG
static char *sym_pool = NULL;
static char *pool_ptr = NULL;
#endif
jl_sym_t *sym;
size_t nb = symbol_nbytes(len);
if (nb >= SYM_POOL_SIZE) {
jl_exceptionf(jl_argumenterror_type, "Symbol length exceeds maximum length");
}
#ifdef MEMDEBUG
sym = (jl_sym_t*)jl_valueof(malloc(nb));
#else
if (sym_pool == NULL || pool_ptr+nb > sym_pool+SYM_POOL_SIZE) {
sym_pool = (char*)malloc(SYM_POOL_SIZE);
pool_ptr = sym_pool;
}
sym = (jl_sym_t*)jl_valueof(pool_ptr);
pool_ptr += nb;
#endif
jl_set_typeof(sym, jl_sym_type);
sym->left = sym->right = NULL;
sym->hash = hash_symbol(str, len);
memcpy(jl_symbol_name(sym), str, len);
jl_symbol_name(sym)[len] = 0;
return sym;
}
static jl_sym_t *mk_symbol(const char *str)
{
#ifndef MEMDEBUG
static char *sym_pool = NULL;
static char *pool_ptr = NULL;
#endif
jl_sym_t *sym;
size_t len = strlen(str);
size_t nb = (sizeof(jl_taggedvalue_t)+sizeof(jl_sym_t)+len+1+7)&-8;
if (nb >= SYM_POOL_SIZE) {
jl_exceptionf(jl_argumenterror_type, "Symbol length exceeds maximum length");
}
#ifdef MEMDEBUG
sym = (jl_sym_t*)&((jl_taggedvalue_t*)malloc(nb))->value;
#else
if (sym_pool == NULL || pool_ptr+nb > sym_pool+SYM_POOL_SIZE) {
sym_pool = (char*)malloc(SYM_POOL_SIZE);
pool_ptr = sym_pool;
}
sym = (jl_sym_t*)&((jl_taggedvalue_t*)pool_ptr)->value;
pool_ptr += nb;
#endif
jl_set_typeof(sym, jl_sym_type);
sym->left = sym->right = NULL;
sym->hash = hash_symbol(str, len);
strcpy(&sym->name[0], str);
return sym;
}
static jl_sym_t *mk_symbol(const char *str)
{
#ifndef MEMDEBUG
static char *sym_pool = NULL;
static char *pool_ptr = NULL;
#endif
jl_sym_t *sym;
size_t len = strlen(str);
size_t nb = (sizeof(jl_sym_t)+len+1+7)&-8;
if (nb >= SYM_POOL_SIZE) {
jl_error("Symbol length exceeds maximum length");
}
#ifdef MEMDEBUG
sym = (jl_sym_t*)malloc(nb);
#else
if (sym_pool == NULL || pool_ptr+nb > sym_pool+SYM_POOL_SIZE) {
sym_pool = malloc(SYM_POOL_SIZE);
pool_ptr = sym_pool;
}
sym = (jl_sym_t*)pool_ptr;
pool_ptr += nb;
#endif
sym->type = (jl_value_t*)jl_sym_type;
sym->left = sym->right = NULL;
sym->hash = hash_symbol(str, len);
strcpy(&sym->name[0], str);
return sym;
}
symbolOop SymbolTable::lookup(const char* name, int len, TRAPS) {
unsigned int hashValue = hash_symbol(name, len);
int index = the_table()->hash_to_index(hashValue);
symbolOop s = the_table()->lookup(index, name, len, hashValue);
// Found
if (s != NULL) return s;
// Otherwise, add to symbol to table
return the_table()->basic_add(index, (u1*)name, len, hashValue, CHECK_NULL);
}
static jl_sym_t *mk_symbol(const char *str)
{
jl_sym_t *sym;
size_t len = strlen(str);
sym = (jl_sym_t*)malloc((sizeof(jl_sym_t)+len+1+7)&-8);
sym->type = (jl_value_t*)jl_sym_type;
sym->left = sym->right = NULL;
sym->hash = hash_symbol(str, len);
strcpy(&sym->name[0], str);
return sym;
}
Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) {
unsigned int hashValue = hash_symbol(name, len);
int index = the_table()->hash_to_index(hashValue);
Symbol* s = the_table()->lookup(index, name, len, hashValue);
// Found
if (s != NULL) return s;
// Grab SymbolTable_lock first.
MutexLocker ml(SymbolTable_lock, THREAD);
// Otherwise, add to symbol to table
return the_table()->basic_add(index, (u1*)name, len, hashValue, true, CHECK_NULL);
}
static jl_sym_t *mk_symbol(const char *str, size_t len)
{
jl_sym_t *sym;
size_t nb = symbol_nbytes(len);
jl_taggedvalue_t *tag = (jl_taggedvalue_t*)jl_gc_perm_alloc_nolock(nb);
sym = (jl_sym_t*)jl_valueof(tag);
// set to old marked since we don't need write barrier on it.
tag->header = ((uintptr_t)jl_sym_type) | GC_OLD_MARKED;
sym->left = sym->right = NULL;
sym->hash = hash_symbol(str, len);
memcpy(jl_symbol_name(sym), str, len);
jl_symbol_name(sym)[len] = 0;
return sym;
}
symbolOop SymbolTable::lookup(symbolHandle sym, int begin, int end, TRAPS) {
char* buffer;
int index, len;
unsigned int hashValue;
char* name;
{
debug_only(No_Safepoint_Verifier nsv;)
name = (char*)sym->base() + begin;
len = end - begin;
hashValue = hash_symbol(name, len);
index = the_table()->hash_to_index(hashValue);
symbolOop s = the_table()->lookup(index, name, len, hashValue);
// Found
if (s != NULL) return s;
}
