From e3d7e5e1c3798b0f6314029587c9963367d8e7db Mon Sep 17 00:00:00 2001 From: Sam Clegg Date: Thu, 18 Apr 2024 11:12:51 -0700 Subject: [PATCH] Rename metadata member names. NFC These names are a legacy holdover from the days when we used wasm-emscripten-finalize to emit the metadata. --- tools/emscripten.py | 44 +++++++++++++++++++-------------------- tools/extract_metadata.py | 38 ++++++++++++++++----------------- tools/link.py | 2 +- 3 files changed, 42 insertions(+), 42 deletions(-) diff --git a/tools/emscripten.py b/tools/emscripten.py index 787598a973cea..35df13bae9afa 100644 --- a/tools/emscripten.py +++ b/tools/emscripten.py @@ -143,8 +143,8 @@ def update_settings_glue(wasm_file, metadata): settings.WEAK_IMPORTS += webassembly.get_weak_imports(wasm_file) settings.WASM_EXPORTS = metadata.all_exports - settings.WASM_GLOBAL_EXPORTS = list(metadata.namedGlobals.keys()) - settings.HAVE_EM_ASM = bool(settings.MAIN_MODULE or len(metadata.asmConsts) != 0) + settings.WASM_GLOBAL_EXPORTS = list(metadata.global_exports.keys()) + settings.HAVE_EM_ASM = bool(settings.MAIN_MODULE or len(metadata.em_asm_consts) != 0) # start with the MVP features, and add any detected features. settings.BINARYEN_FEATURES = ['--mvp-features'] + metadata.features @@ -163,7 +163,7 @@ def update_settings_glue(wasm_file, metadata): # When using dynamic linking the main function might be in a side module. # To be safe assume they do take input parameters. - settings.MAIN_READS_PARAMS = metadata.mainReadsParams or bool(settings.MAIN_MODULE) + settings.MAIN_READS_PARAMS = metadata.main_reads_params or bool(settings.MAIN_MODULE) if settings.MAIN_READS_PARAMS and not settings.STANDALONE_WASM: # callMain depends on this library function settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$stringToUTF8OnStack'] @@ -173,7 +173,7 @@ def update_settings_glue(wasm_file, metadata): # exported. In theory it should always be present since its defined in compiler-rt. assert 'emscripten_stack_get_end' in metadata.function_exports - for deps in metadata.jsDeps: + for deps in metadata.js_deps: settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.extend(deps.split(',')) @@ -290,19 +290,19 @@ def trim_asm_const_body(body): return body -def create_named_globals(metadata): - named_globals = [] - for k, v in metadata.namedGlobals.items(): +def create_global_exports(metadata): + global_exports = [] + for k, v in metadata.global_exports.items(): v = int(v) if settings.RELOCATABLE: v += settings.GLOBAL_BASE mangled = asmjs_mangle(k) if settings.MINIMAL_RUNTIME: - named_globals.append("var %s = %s;" % (mangled, v)) + global_exports.append("var %s = %s;" % (mangled, v)) else: - named_globals.append("var %s = Module['%s'] = %s;" % (mangled, mangled, v)) + global_exports.append("var %s = Module['%s'] = %s;" % (mangled, mangled, v)) - return '\n'.join(named_globals) + return '\n'.join(global_exports) def emscript(in_wasm, out_wasm, outfile_js, js_syms, finalize=True): @@ -340,7 +340,7 @@ def emscript(in_wasm, out_wasm, outfile_js, js_syms, finalize=True): if finalize: update_settings_glue(out_wasm, metadata) - if not settings.WASM_BIGINT and metadata.emJsFuncs: + if not settings.WASM_BIGINT and metadata.em_js_funcs: import_map = {} with webassembly.Module(in_wasm) as module: @@ -349,7 +349,7 @@ def emscript(in_wasm, out_wasm, outfile_js, js_syms, finalize=True): if imp.module not in ('GOT.mem', 'GOT.func'): import_map[imp.field] = imp - for em_js_func, raw in metadata.emJsFuncs.items(): + for em_js_func, raw in metadata.em_js_funcs.items(): c_sig = raw.split('<::>')[0].strip('()') if not c_sig or c_sig == 'void': c_sig = [] @@ -405,7 +405,7 @@ def emscript(in_wasm, out_wasm, outfile_js, js_syms, finalize=True): if settings.ASYNCIFY == 1: metadata.imports += ['__asyncify_state', '__asyncify_data'] - if metadata.invokeFuncs: + if metadata.invoke_funcs: settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$getWasmTableEntry'] glue, forwarded_data = compile_javascript() @@ -674,7 +674,7 @@ def create_tsd(metadata, embind_tsd): def create_asm_consts(metadata): asm_consts = {} - for addr, const in metadata.asmConsts.items(): + for addr, const in metadata.em_asm_consts.items(): body = trim_asm_const_body(const) args = [] max_arity = 16 @@ -735,7 +735,7 @@ def func_type_to_sig(type): def create_em_js(metadata): em_js_funcs = [] separator = '<::>' - for name, raw in metadata.emJsFuncs.items(): + for name, raw in metadata.em_js_funcs.items(): assert separator in raw args, body = raw.split(separator, 1) args = args[1:-1] @@ -746,8 +746,8 @@ def create_em_js(metadata): arg_names = [arg.split()[-1].replace('*', '') for arg in args if arg] args = ','.join(arg_names) func = f'function {name}({args}) {body}' - if (settings.MAIN_MODULE or settings.ASYNCIFY == 2) and name in metadata.emJsFuncTypes: - sig = func_type_to_sig(metadata.emJsFuncTypes[name]) + if (settings.MAIN_MODULE or settings.ASYNCIFY == 2) and name in metadata.em_js_func_types: + sig = func_type_to_sig(metadata.em_js_func_types[name]) func = func + f'\n{name}.sig = \'{sig}\';' em_js_funcs.append(func) @@ -816,10 +816,10 @@ def create_sending(metadata, library_symbols): # Map of wasm imports to mangled/external/JS names send_items_map = {} - for name in metadata.invokeFuncs: + for name in metadata.invoke_funcs: send_items_map[name] = name for name in metadata.imports: - if name in metadata.emJsFuncs: + if name in metadata.em_js_funcs: send_items_map[name] = name else: send_items_map[name] = asmjs_mangle(name) @@ -951,7 +951,7 @@ def create_receiving(function_exports): def create_module(receiving, metadata, library_symbols): - receiving += create_named_globals(metadata) + receiving += create_global_exports(metadata) module = [] sending = create_sending(metadata, library_symbols) @@ -973,7 +973,7 @@ def create_module(receiving, metadata, library_symbols): if settings.SUPPORT_LONGJMP == 'emscripten' or not settings.DISABLE_EXCEPTION_CATCHING: module.append(create_invoke_wrappers(metadata)) else: - assert not metadata.invokeFuncs, "invoke_ functions exported but exceptions and longjmp are both disabled" + assert not metadata.invoke_funcs, "invoke_ functions exported but exceptions and longjmp are both disabled" if settings.MEMORY64 or settings.CAN_ADDRESS_2GB: module.append(create_pointer_conversion_wrappers(metadata)) return module @@ -982,7 +982,7 @@ def create_module(receiving, metadata, library_symbols): def create_invoke_wrappers(metadata): """Asm.js-style exception handling: invoke wrapper generation.""" invoke_wrappers = '' - for invoke in metadata.invokeFuncs: + for invoke in metadata.invoke_funcs: sig = removeprefix(invoke, 'invoke_') invoke_wrappers += '\n' + js_manipulation.make_invoke(sig) + '\n' return invoke_wrappers diff --git a/tools/extract_metadata.py b/tools/extract_metadata.py index 52a556b5d29a0..d457b156dfcb8 100644 --- a/tools/extract_metadata.py +++ b/tools/extract_metadata.py @@ -239,8 +239,8 @@ def get_main_reads_params(module, export_map): return True -def get_named_globals(module, exports): - named_globals = {} +def get_global_exports(module, exports): + global_exports = {} internal_start_stop_symbols = set(['__start_em_asm', '__stop_em_asm', '__start_em_lib_deps', '__stop_em_lib_deps', '__em_lib_deps']) @@ -250,8 +250,8 @@ def get_named_globals(module, exports): if export.name in internal_start_stop_symbols or any(export.name.startswith(p) for p in internal_prefixes): continue g = module.get_global(export.index) - named_globals[export.name] = str(get_global_value(g)) - return named_globals + global_exports[export.name] = str(get_global_value(g)) + return global_exports def get_function_exports(module): @@ -279,7 +279,7 @@ def update_metadata(filename, metadata): metadata.all_exports = [utils.removeprefix(e.name, '__em_js__') for e in module.get_exports()] metadata.imports = imports - metadata.invokeFuncs = invoke_funcs + metadata.invoke_funcs = invoke_funcs def get_string_at(module, address): @@ -292,14 +292,14 @@ def get_string_at(module, address): class Metadata: imports: List[str] export: List[str] - asmConsts: Dict[int, str] - jsDeps: List[str] - emJsFuncs: Dict[str, str] - emJsFuncTypes: Dict[str, str] + em_asm_consts: Dict[int, str] + js_deps: List[str] + em_js_funcs: Dict[str, str] + em_js_func_types: Dict[str, str] features: List[str] - invokeFuncs: List[str] - mainReadsParams: bool - namedGlobals: List[str] + invoke_funcs: List[str] + main_reads_params: bool + global_exports: List[str] def __init__(self): pass @@ -347,14 +347,14 @@ def extract_metadata(filename): metadata.imports = import_names metadata.function_exports = get_function_exports(module) metadata.all_exports = [utils.removeprefix(e.name, '__em_js__') for e in exports] - metadata.asmConsts = get_section_strings(module, export_map, 'em_asm') - metadata.jsDeps = [d for d in get_section_strings(module, export_map, 'em_lib_deps').values() if d] - metadata.emJsFuncs = em_js_funcs - metadata.emJsFuncTypes = em_js_func_types + metadata.em_asm_consts = get_section_strings(module, export_map, 'em_asm') + metadata.js_deps = [d for d in get_section_strings(module, export_map, 'em_lib_deps').values() if d] + metadata.em_js_funcs = em_js_funcs + metadata.em_js_func_types = em_js_func_types metadata.features = features - metadata.invokeFuncs = invoke_funcs - metadata.mainReadsParams = get_main_reads_params(module, export_map) - metadata.namedGlobals = get_named_globals(module, exports) + metadata.invoke_funcs = invoke_funcs + metadata.main_reads_params = get_main_reads_params(module, export_map) + metadata.global_exports = get_global_exports(module, exports) # print("Metadata parsed: " + pprint.pformat(metadata)) return metadata diff --git a/tools/link.py b/tools/link.py index a029180c0b7bb..2be32dc0c02dc 100644 --- a/tools/link.py +++ b/tools/link.py @@ -2793,7 +2793,7 @@ def process_dynamic_libs(dylibs, lib_dirs): imports = [i.field for i in imports if i.kind in (webassembly.ExternType.FUNC, webassembly.ExternType.GLOBAL, webassembly.ExternType.TAG)] # For now we ignore `invoke_` functions imported by side modules and rely # on the dynamic linker to create them on the fly. - # TODO(sbc): Integrate with metadata.invokeFuncs that comes from the + # TODO(sbc): Integrate with metadata.invoke_funcs that comes from the # main module to avoid creating new invoke functions at runtime. imports = set(imports) imports = set(i for i in imports if not i.startswith('invoke_'))