[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

@@ -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<JSArrayBuffer> mem_buffer =
@@ -40,37 +40,37 @@ class InterpreterHandle {
       instance_.mem_size = 0;
     } else {
       instance_.mem_start =
-          reinterpret_cast<byte *>(mem_buffer->backing_store());
+          reinterpret_cast<byte*>(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<const byte> 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<int>(sig->parameter_count());
     ScopedVector<WasmVal> 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<ctype *>(arg_buf_ptr)); \
+#define CASE_ARG_TYPE(type, ctype)                                  \
+  case type:                                                        \
+    DCHECK_EQ(param_size, sizeof(ctype));                           \
+    wasm_args[i] = WasmVal(*reinterpret_cast<ctype*>(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<ctype *>(arg_buffer) = ret_val.to<ctype>();        \
+    *reinterpret_cast<ctype*>(arg_buffer) = ret_val.to<ctype>();         \
     break;
       switch (sig->GetReturn(0)) {
         CASE_RET_TYPE(kWasmI32, uint32_t)
@@ -138,12 +138,12 @@ class InterpreterHandle {
   }
 };
 
-InterpreterHandle *GetOrCreateInterpreterHandle(
-    Isolate *isolate, Handle<WasmDebugInfo> debug_info) {
+InterpreterHandle* GetOrCreateInterpreterHandle(
+    Isolate* isolate, Handle<WasmDebugInfo> debug_info) {
   Handle<Object> 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<InterpreterHandle>::New(isolate, cpp_handle);
     debug_info->set(WasmDebugInfo::kInterpreterHandle, *handle);
   }
@@ -151,7 +151,7 @@ InterpreterHandle *GetOrCreateInterpreterHandle(
   return Handle<Managed<InterpreterHandle>>::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<FixedArray> GetOrCreateInterpretedFunctions(
-    Isolate *isolate, Handle<WasmDebugInfo> debug_info) {
+    Isolate* isolate, Handle<WasmDebugInfo> debug_info) {
   Handle<Object> obj(debug_info->get(WasmDebugInfo::kInterpretedFunctions),
                      isolate);
   if (!obj->IsUndefined(isolate)) return Handle<FixedArray>::cast(obj);
@@ -170,39 +170,39 @@ Handle<FixedArray> 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<WasmDebugInfo> debug_info,
                                  int func_index) {
   Handle<FixedArray> interpreted_functions =
@@ -225,50 +225,50 @@ void EnsureRedirectToInterpreter(Isolate *isolate,
 }  // namespace
 
 Handle<WasmDebugInfo> WasmDebugInfo::New(Handle<WasmInstanceObject> instance) {
-  Isolate *isolate = instance->GetIsolate();
-  Factory *factory = isolate->factory();
+  Isolate* isolate = instance->GetIsolate();
+  Factory* factory = isolate->factory();
   Handle<FixedArray> arr = factory->NewFixedArray(kFieldCount, TENURED);
   arr->set(kInstance, *instance);
   return Handle<WasmDebugInfo>::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<WasmDebugInfo *>(object);
+  return reinterpret_cast<WasmDebugInfo*>(object);
 }
 
-WasmInstanceObject *WasmDebugInfo::wasm_instance() {
+WasmInstanceObject* WasmDebugInfo::wasm_instance() {
   return WasmInstanceObject::cast(get(kInstance));
 }
 
 void WasmDebugInfo::SetBreakpoint(Handle<WasmDebugInfo> 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<WasmDebugInfo> 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<uint32_t>(func_index), arg_buffer);
 }