[wasm] Store function names in the wasm object

src/compiler/pipeline.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/pipeline.h"
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/base/adapters.h"
@@ skipping 1278 matching lines @@
   // Kill the Typer and thereby uninstall the decorator (if any).
   typer.Reset(nullptr);
 
   return ScheduleAndGenerateCode(
       Linkage::ComputeIncoming(data.instruction_zone(), info()));
 }
 
 Handle<Code> Pipeline::GenerateWASMCode(CompilationInfo* info,
                                         CallDescriptor* call_descriptor,
                                         Graph* graph,
-                                        SourcePositionTable* source_positions) {
+                                        SourcePositionTable* source_positions,
+                                        Handle<Object> wasm_obj,
+                                        uint32_t func_index) {
   // Construct a pipeline for scheduling and code generation.
   ZonePool zone_pool(info->isolate()->allocator());
   PipelineData data(&zone_pool, info, graph, source_positions);
   base::SmartPointer<PipelineStatistics> pipeline_statistics;
   if (FLAG_turbo_stats) {
     pipeline_statistics.Reset(new PipelineStatistics(info, &zone_pool));
     pipeline_statistics->BeginPhaseKind("test codegen");
   }
 
   Pipeline pipeline(info);
   pipeline.data_ = &data;
   if (data.schedule() == nullptr) {
     // TODO(rossberg): Should this really be untyped?
     pipeline.RunPrintAndVerify("Machine", true);
   }
 
   Handle<Code> code = pipeline.ScheduleAndGenerateCode(call_descriptor);
+
+  Factory* factory = info->isolate()->factory();

[Michael Starzinger, 2016/04/22 11:59:35]

Can we move all of this into the WASM compiler?

[Clemens Hammacher, 2016/04/22 14:38:40]

Yes we can :)
It also saves us the check whether we have a wasm_obj, since this is distinct
for each caller.

But now, GenerateWASMCode is identical to GenerateCodeForTesting again (except
for the schedule parameter, which is always NULL for wasm).
Should be keep it anyway?

[titzer, 2016/04/25 11:15:05]

Yes, let's keep it to convey the intent, and they may diverge again in the
future. If you want to factor out a common helper routine, that's fine.

+  Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
+  // Generate deopt data for getting information about the executed wasm
+  // function later. Either store wasm object and function index (default), or
+  // just the function name (for debugging code where no wasm object is
+  // available).
+  if (wasm_obj.is_null()) {
+    MaybeHandle<String> maybeName =
+        factory->NewStringFromUtf8(info->GetFunctionName(), TENURED);
+    if (!maybeName.is_null()) deopt_data->set(0, *maybeName.ToHandleChecked());
+  } else {
+    deopt_data->set(0, *wasm_obj);
+    deopt_data->set(1, Smi::FromInt(func_index));
+  }
+  deopt_data->set_length(2);
+  code->set_deoptimization_data(*deopt_data);
+
   return code;
 }
 
 Handle<Code> Pipeline::GenerateCodeForCodeStub(Isolate* isolate,
                                                CallDescriptor* call_descriptor,
                                                Graph* graph, Schedule* schedule,
                                                Code::Flags flags,
                                                const char* debug_name) {
   CompilationInfo info(CStrVector(debug_name), isolate, graph->zone(), flags);
 
@@ skipping 268 matching lines @@
   }
 
   data->DeleteRegisterAllocationZone();
 }
 
 Isolate* Pipeline::isolate() const { return info()->isolate(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8