From 2702d0fbe31f58bebb26d1946295632648a85f7e Mon Sep 17 00:00:00 2001 From: clemensh Date: Mon, 16 Jan 2017 07:44:06 -0800 Subject: [PATCH] [wasm] [codestyle] Fix pointer alignment in wasm-debug.cc Our .clang-format is derived on the Google style, which sets PointerAlignment to left (e.g. "Type* name"), but sets DerivePointerAlignment to true. Once we started with the wrong style, this made all new code in wasm-debug.cc use PointerAlignment=right, resulting in lots of code using the wrong style. For this CL, I ran clang-format -style="{DerivePointerAlignment: false, BasedOnStyle: \ Google}" -i src/wasm/wasm-debug.cc R=titzer@chromium.org Review-Url: https://codereview.chromium.org/2635003002 Cr-Commit-Position: refs/heads/master@{#42380} --- src/wasm/wasm-debug.cc | 88 +++++++++++++++++++++--------------------- 1 file changed, 44 insertions(+), 44 deletions(-) diff --git a/src/wasm/wasm-debug.cc b/src/wasm/wasm-debug.cc index b2e2bd0845..6cb865d59c 100644 --- a/src/wasm/wasm-debug.cc +++ b/src/wasm/wasm-debug.cc @@ -29,7 +29,7 @@ class InterpreterHandle { public: // Initialize in the right order, using helper methods to make this possible. // WasmInterpreter has to be allocated in place, since it is not movable. - InterpreterHandle(Isolate *isolate, WasmDebugInfo *debug_info) + InterpreterHandle(Isolate* isolate, WasmDebugInfo* debug_info) : instance_(debug_info->wasm_instance()->compiled_module()->module()), interpreter_(GetBytesEnv(&instance_, debug_info), &allocator_) { Handle mem_buffer = @@ -40,37 +40,37 @@ class InterpreterHandle { instance_.mem_size = 0; } else { instance_.mem_start = - reinterpret_cast(mem_buffer->backing_store()); + reinterpret_cast(mem_buffer->backing_store()); CHECK(mem_buffer->byte_length()->ToUint32(&instance_.mem_size)); } } - static ModuleBytesEnv GetBytesEnv(WasmInstance *instance, - WasmDebugInfo *debug_info) { + static ModuleBytesEnv GetBytesEnv(WasmInstance* instance, + WasmDebugInfo* debug_info) { // Return raw pointer into heap. The WasmInterpreter will make its own copy // of this data anyway, and there is no heap allocation in-between. - SeqOneByteString *bytes_str = + SeqOneByteString* bytes_str = debug_info->wasm_instance()->compiled_module()->module_bytes(); Vector bytes(bytes_str->GetChars(), bytes_str->length()); return ModuleBytesEnv(instance->module, instance, bytes); } - WasmInterpreter *interpreter() { return &interpreter_; } - const WasmModule *module() { return instance_.module; } + WasmInterpreter* interpreter() { return &interpreter_; } + const WasmModule* module() { return instance_.module; } - void Execute(uint32_t func_index, uint8_t *arg_buffer) { + void Execute(uint32_t func_index, uint8_t* arg_buffer) { DCHECK_GE(module()->functions.size(), func_index); - FunctionSig *sig = module()->functions[func_index].sig; + FunctionSig* sig = module()->functions[func_index].sig; DCHECK_GE(kMaxInt, sig->parameter_count()); int num_params = static_cast(sig->parameter_count()); ScopedVector wasm_args(num_params); - uint8_t *arg_buf_ptr = arg_buffer; + uint8_t* arg_buf_ptr = arg_buffer; for (int i = 0; i < num_params; ++i) { uint32_t param_size = 1 << ElementSizeLog2Of(sig->GetParam(i)); -#define CASE_ARG_TYPE(type, ctype) \ - case type: \ - DCHECK_EQ(param_size, sizeof(ctype)); \ - wasm_args[i] = WasmVal(*reinterpret_cast(arg_buf_ptr)); \ +#define CASE_ARG_TYPE(type, ctype) \ + case type: \ + DCHECK_EQ(param_size, sizeof(ctype)); \ + wasm_args[i] = WasmVal(*reinterpret_cast(arg_buf_ptr)); \ break; switch (sig->GetParam(i)) { CASE_ARG_TYPE(kWasmI32, uint32_t) @@ -84,7 +84,7 @@ class InterpreterHandle { arg_buf_ptr += param_size; } - WasmInterpreter::Thread *thread = interpreter_.GetThread(0); + WasmInterpreter::Thread* thread = interpreter_.GetThread(0); // We do not support reentering an already running interpreter at the moment // (like INTERPRETER -> JS -> WASM -> INTERPRETER). DCHECK(thread->state() == WasmInterpreter::STOPPED || @@ -123,7 +123,7 @@ class InterpreterHandle { #define CASE_RET_TYPE(type, ctype) \ case type: \ DCHECK_EQ(1 << ElementSizeLog2Of(sig->GetReturn(0)), sizeof(ctype)); \ - *reinterpret_cast(arg_buffer) = ret_val.to(); \ + *reinterpret_cast(arg_buffer) = ret_val.to(); \ break; switch (sig->GetReturn(0)) { CASE_RET_TYPE(kWasmI32, uint32_t) @@ -138,12 +138,12 @@ class InterpreterHandle { } }; -InterpreterHandle *GetOrCreateInterpreterHandle( - Isolate *isolate, Handle debug_info) { +InterpreterHandle* GetOrCreateInterpreterHandle( + Isolate* isolate, Handle debug_info) { Handle handle(debug_info->get(WasmDebugInfo::kInterpreterHandle), isolate); if (handle->IsUndefined(isolate)) { - InterpreterHandle *cpp_handle = new InterpreterHandle(isolate, *debug_info); + InterpreterHandle* cpp_handle = new InterpreterHandle(isolate, *debug_info); handle = Managed::New(isolate, cpp_handle); debug_info->set(WasmDebugInfo::kInterpreterHandle, *handle); } @@ -151,7 +151,7 @@ InterpreterHandle *GetOrCreateInterpreterHandle( return Handle>::cast(handle)->get(); } -int GetNumFunctions(WasmInstanceObject *instance) { +int GetNumFunctions(WasmInstanceObject* instance) { size_t num_functions = instance->compiled_module()->module()->functions.size(); DCHECK_GE(kMaxInt, num_functions); @@ -159,7 +159,7 @@ int GetNumFunctions(WasmInstanceObject *instance) { } Handle GetOrCreateInterpretedFunctions( - Isolate *isolate, Handle debug_info) { + Isolate* isolate, Handle debug_info) { Handle obj(debug_info->get(WasmDebugInfo::kInterpretedFunctions), isolate); if (!obj->IsUndefined(isolate)) return Handle::cast(obj); @@ -170,39 +170,39 @@ Handle GetOrCreateInterpretedFunctions( return new_arr; } -void RedirectCallsitesInCode(Code *code, Code *old_target, Code *new_target) { +void RedirectCallsitesInCode(Code* code, Code* old_target, Code* new_target) { DisallowHeapAllocation no_gc; for (RelocIterator it(code, RelocInfo::kCodeTargetMask); !it.done(); it.next()) { DCHECK(RelocInfo::IsCodeTarget(it.rinfo()->rmode())); - Code *target = Code::GetCodeFromTargetAddress(it.rinfo()->target_address()); + Code* target = Code::GetCodeFromTargetAddress(it.rinfo()->target_address()); if (target != old_target) continue; it.rinfo()->set_target_address(new_target->instruction_start()); } } -void RedirectCallsitesInInstance(Isolate *isolate, WasmInstanceObject *instance, - Code *old_target, Code *new_target) { +void RedirectCallsitesInInstance(Isolate* isolate, WasmInstanceObject* instance, + Code* old_target, Code* new_target) { DisallowHeapAllocation no_gc; // Redirect all calls in wasm functions. - FixedArray *code_table = instance->compiled_module()->ptr_to_code_table(); + FixedArray* code_table = instance->compiled_module()->ptr_to_code_table(); for (int i = 0, e = GetNumFunctions(instance); i < e; ++i) { RedirectCallsitesInCode(Code::cast(code_table->get(i)), old_target, new_target); } // Redirect all calls in exported functions. - FixedArray *weak_exported_functions = + FixedArray* weak_exported_functions = instance->compiled_module()->ptr_to_weak_exported_functions(); for (int i = 0, e = weak_exported_functions->length(); i != e; ++i) { - WeakCell *weak_function = WeakCell::cast(weak_exported_functions->get(i)); + WeakCell* weak_function = WeakCell::cast(weak_exported_functions->get(i)); if (weak_function->cleared()) continue; - Code *code = JSFunction::cast(weak_function->value())->code(); + Code* code = JSFunction::cast(weak_function->value())->code(); RedirectCallsitesInCode(code, old_target, new_target); } } -void EnsureRedirectToInterpreter(Isolate *isolate, +void EnsureRedirectToInterpreter(Isolate* isolate, Handle debug_info, int func_index) { Handle interpreted_functions = @@ -225,50 +225,50 @@ void EnsureRedirectToInterpreter(Isolate *isolate, } // namespace Handle WasmDebugInfo::New(Handle instance) { - Isolate *isolate = instance->GetIsolate(); - Factory *factory = isolate->factory(); + Isolate* isolate = instance->GetIsolate(); + Factory* factory = isolate->factory(); Handle arr = factory->NewFixedArray(kFieldCount, TENURED); arr->set(kInstance, *instance); return Handle::cast(arr); } -bool WasmDebugInfo::IsDebugInfo(Object *object) { +bool WasmDebugInfo::IsDebugInfo(Object* object) { if (!object->IsFixedArray()) return false; - FixedArray *arr = FixedArray::cast(object); + FixedArray* arr = FixedArray::cast(object); if (arr->length() != kFieldCount) return false; if (!IsWasmInstance(arr->get(kInstance))) return false; - Isolate *isolate = arr->GetIsolate(); + Isolate* isolate = arr->GetIsolate(); if (!arr->get(kInterpreterHandle)->IsUndefined(isolate) && !arr->get(kInterpreterHandle)->IsForeign()) return false; return true; } -WasmDebugInfo *WasmDebugInfo::cast(Object *object) { +WasmDebugInfo* WasmDebugInfo::cast(Object* object) { DCHECK(IsDebugInfo(object)); - return reinterpret_cast(object); + return reinterpret_cast(object); } -WasmInstanceObject *WasmDebugInfo::wasm_instance() { +WasmInstanceObject* WasmDebugInfo::wasm_instance() { return WasmInstanceObject::cast(get(kInstance)); } void WasmDebugInfo::SetBreakpoint(Handle debug_info, int func_index, int offset) { - Isolate *isolate = debug_info->GetIsolate(); - InterpreterHandle *handle = GetOrCreateInterpreterHandle(isolate, debug_info); - WasmInterpreter *interpreter = handle->interpreter(); + Isolate* isolate = debug_info->GetIsolate(); + InterpreterHandle* handle = GetOrCreateInterpreterHandle(isolate, debug_info); + WasmInterpreter* interpreter = handle->interpreter(); DCHECK_LE(0, func_index); DCHECK_GT(handle->module()->functions.size(), func_index); - const WasmFunction *func = &handle->module()->functions[func_index]; + const WasmFunction* func = &handle->module()->functions[func_index]; interpreter->SetBreakpoint(func, offset, true); EnsureRedirectToInterpreter(isolate, debug_info, func_index); } void WasmDebugInfo::RunInterpreter(Handle debug_info, - int func_index, uint8_t *arg_buffer) { + int func_index, uint8_t* arg_buffer) { DCHECK_LE(0, func_index); - InterpreterHandle *interp_handle = + InterpreterHandle* interp_handle = GetOrCreateInterpreterHandle(debug_info->GetIsolate(), debug_info); interp_handle->Execute(static_cast(func_index), arg_buffer); }