static struct _glapi_function * set_entry_info( struct _glapi_function * entry, const char * signature, unsigned offset ) { char * sig_dup = NULL; if (signature == NULL) return NULL; sig_dup = str_dup(signature); if (sig_dup == NULL) return NULL; fill_in_entrypoint_offset(entry->dispatch_stub, offset); entry->parameter_signature = sig_dup; entry->dispatch_offset = offset; return entry; }
/** * Generate a dispatch function (entrypoint) which jumps through * the given slot number (offset) in the current dispatch table. * We need assembly language in order to accomplish this. */ _glapi_proc generate_entrypoint(unsigned int functionOffset) { /* 32 is chosen as something of a magic offset. For x86, the dispatch * at offset 32 is the first one where the offset in the * "jmp OFFSET*4(%eax)" can't be encoded in a single byte. */ const GLubyte * const template_func = gl_dispatch_functions_start + (DISPATCH_FUNCTION_SIZE * 32); GLubyte * const code = (GLubyte *) u_execmem_alloc(DISPATCH_FUNCTION_SIZE); if ( code != NULL ) { (void) memcpy(code, template_func, DISPATCH_FUNCTION_SIZE); fill_in_entrypoint_offset( (_glapi_proc) code, functionOffset ); } return (_glapi_proc) code; }
PUBLIC int _glapi_add_dispatch( const char * const * function_names, const char * parameter_signature ) { static int next_dynamic_offset = _gloffset_FIRST_DYNAMIC; const char * const real_sig = (parameter_signature != NULL) ? parameter_signature : ""; struct _glapi_function * entry[8]; GLboolean is_static[8]; unsigned i; unsigned j; int offset = ~0; int new_offset; (void) memset( is_static, 0, sizeof( is_static ) ); (void) memset( entry, 0, sizeof( entry ) ); for ( i = 0 ; function_names[i] != NULL ; i++ ) { /* Do some trivial validation on the name of the function. */ if (!function_names[i] || function_names[i][0] != 'g' || function_names[i][1] != 'l') return GL_FALSE; /* Determine if the named function already exists. If the function does * exist, it must have the same parameter signature as the function * being added. */ new_offset = get_static_proc_offset(function_names[i]); if (new_offset >= 0) { /* FIXME: Make sure the parameter signatures match! How do we get * FIXME: the parameter signature for static functions? */ if ( (offset != ~0) && (new_offset != offset) ) { return -1; } is_static[i] = GL_TRUE; offset = new_offset; } for ( j = 0 ; j < NumExtEntryPoints ; j++ ) { if (strcmp(ExtEntryTable[j].name, function_names[i]) == 0) { /* The offset may be ~0 if the function name was added by * glXGetProcAddress but never filled in by the driver. */ if (ExtEntryTable[j].dispatch_offset != ~0) { if (strcmp(real_sig, ExtEntryTable[j].parameter_signature) != 0) { return -1; } if ( (offset != ~0) && (ExtEntryTable[j].dispatch_offset != offset) ) { return -1; } offset = ExtEntryTable[j].dispatch_offset; } entry[i] = & ExtEntryTable[j]; break; } } } if (offset == ~0) { offset = next_dynamic_offset; next_dynamic_offset++; } for ( i = 0 ; function_names[i] != NULL ; i++ ) { if (! is_static[i] ) { if (entry[i] == NULL) { entry[i] = add_function_name( function_names[i] ); if (entry[i] == NULL) { /* FIXME: Possible memory leak here. */ return -1; } } entry[i]->parameter_signature = str_dup(real_sig); fill_in_entrypoint_offset(entry[i]->dispatch_stub, offset); entry[i]->dispatch_offset = offset; } } return offset; }
/** * Generate a dispatch function (entrypoint) which jumps through * the given slot number (offset) in the current dispatch table. * We need assembly language in order to accomplish this. */ static _glapi_proc generate_entrypoint(GLuint functionOffset) { #if defined(USE_X86_ASM) /* 32 is chosen as something of a magic offset. For x86, the dispatch * at offset 32 is the first one where the offset in the * "jmp OFFSET*4(%eax)" can't be encoded in a single byte. */ const GLubyte * const template_func = gl_dispatch_functions_start + (DISPATCH_FUNCTION_SIZE * 32); GLubyte * const code = (GLubyte *) malloc(DISPATCH_FUNCTION_SIZE); if ( code != NULL ) { (void) memcpy(code, template_func, DISPATCH_FUNCTION_SIZE); fill_in_entrypoint_offset( (_glapi_proc) code, functionOffset ); } return (_glapi_proc) code; #elif defined(USE_SPARC_ASM) #ifdef __arch64__ static const unsigned int insn_template[] = { 0x05000000, /* sethi %uhi(_glapi_Dispatch), %g2 */ 0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */ 0x8410a000, /* or %g2, %ulo(_glapi_Dispatch), %g2 */ 0x82106000, /* or %g1, %lo(_glapi_Dispatch), %g1 */ 0x8528b020, /* sllx %g2, 32, %g2 */ 0xc2584002, /* ldx [%g1 + %g2], %g1 */ 0x05000000, /* sethi %hi(8 * glapioffset), %g2 */ 0x8410a000, /* or %g2, %lo(8 * glapioffset), %g2 */ 0xc6584002, /* ldx [%g1 + %g2], %g3 */ 0x81c0c000, /* jmpl %g3, %g0 */ 0x01000000 /* nop */ }; #else static const unsigned int insn_template[] = { 0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */ 0xc2006000, /* ld [%g1 + %lo(_glapi_Dispatch)], %g1 */ 0xc6006000, /* ld [%g1 + %lo(4*glapioffset)], %g3 */ 0x81c0c000, /* jmpl %g3, %g0 */ 0x01000000 /* nop */ }; #endif /* __arch64__ */ unsigned int *code = (unsigned int *) malloc(sizeof(insn_template)); unsigned long glapi_addr = (unsigned long) &_glapi_Dispatch; if (code) { memcpy(code, insn_template, sizeof(insn_template)); #ifdef __arch64__ code[0] |= (glapi_addr >> (32 + 10)); code[1] |= ((glapi_addr & 0xffffffff) >> 10); __glapi_sparc_icache_flush(&code[0]); code[2] |= ((glapi_addr >> 32) & ((1 << 10) - 1)); code[3] |= (glapi_addr & ((1 << 10) - 1)); __glapi_sparc_icache_flush(&code[2]); code[6] |= ((functionOffset * 8) >> 10); code[7] |= ((functionOffset * 8) & ((1 << 10) - 1)); __glapi_sparc_icache_flush(&code[6]); #else code[0] |= (glapi_addr >> 10); code[1] |= (glapi_addr & ((1 << 10) - 1)); __glapi_sparc_icache_flush(&code[0]); code[2] |= (functionOffset * 4); __glapi_sparc_icache_flush(&code[2]); #endif /* __arch64__ */ } return (_glapi_proc) code; #else (void) functionOffset; return NULL; #endif /* USE_*_ASM */ }