[wasm] Decouple function name and exported name in WasmFunctionBuilder

src/asmjs/asm-wasm-builder.cc

 // Copyright 2015 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/v8.h"
 
 // Required to get M_E etc. in MSVC.
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #endif
@@ skipping 64 matching lines @@
     builder_->MarkStartFunction(init_function_);
   }
 
   void BuildForeignInitFunction() {
     foreign_init_function_ = builder_->AddFunction();
     FunctionSig::Builder b(zone(), 0, foreign_variables_.size());
     for (auto i = foreign_variables_.begin(); i != foreign_variables_.end();
          ++i) {
       b.AddParam(i->type);
     }
-    foreign_init_function_->SetExported();
-    std::string raw_name = "__foreign_init__";
-    foreign_init_function_->SetName(
-        AsmWasmBuilder::foreign_init_name,
-        static_cast<int>(strlen(AsmWasmBuilder::foreign_init_name)));
-
-    foreign_init_function_->SetName(raw_name.data(),
-                                    static_cast<int>(raw_name.size()));
+    foreign_init_function_->ExportAs(
+        CStrVector(AsmWasmBuilder::foreign_init_name));
     foreign_init_function_->SetSignature(b.Build());
     for (size_t pos = 0; pos < foreign_variables_.size(); ++pos) {
       foreign_init_function_->EmitGetLocal(static_cast<uint32_t>(pos));
       ForeignVariable* fv = &foreign_variables_[pos];
       uint32_t index = LookupOrInsertGlobal(fv->var, fv->type);
       foreign_init_function_->EmitWithVarInt(kExprSetGlobal, index);
     }
   }
 
   i::Handle<i::FixedArray> GetForeignArgs() {
@@ skipping 454 matching lines @@
         current_function_builder_->EmitWithVarInt(
             kExprGetGlobal, LookupOrInsertGlobal(var, var_type));
       } else {
         current_function_builder_->EmitGetLocal(
             LookupOrInsertLocal(var, var_type));
       }
     } else if (scope_ == kExportScope) {
       Variable* var = expr->var();
       DCHECK(var->is_function());
       WasmFunctionBuilder* function = LookupOrInsertFunction(var);
-      function->SetExported();
-      function->SetName(
-          AsmWasmBuilder::single_function_name,
-          static_cast<int>(strlen(AsmWasmBuilder::single_function_name)));
+      function->ExportAs(CStrVector(AsmWasmBuilder::single_function_name));
     }
   }
 
   void VisitLiteral(Literal* expr) {
     Handle<Object> value = expr->value();
     if (!(value->IsNumber() || expr->raw_value()->IsTrue() ||
           expr->raw_value()->IsFalse()) ||
         (scope_ != kFuncScope && scope_ != kInitScope)) {
       return;
     }
@@ skipping 63 matching lines @@
       DCHECK_EQ(kExportScope, scope_);
       VariableProxy* expr = prop->value()->AsVariableProxy();
       DCHECK_NOT_NULL(expr);
       Variable* var = expr->var();
       Literal* name = prop->key()->AsLiteral();
       DCHECK_NOT_NULL(name);
       DCHECK(name->IsPropertyName());
       const AstRawString* raw_name = name->AsRawPropertyName();
       if (var->is_function()) {
         WasmFunctionBuilder* function = LookupOrInsertFunction(var);
-        function->SetExported();
-        function->SetName(reinterpret_cast<const char*>(raw_name->raw_data()),
-                          raw_name->length());
+        function->Export();
+        function->SetName({reinterpret_cast<const char*>(raw_name->raw_data()),
+                           raw_name->length()});
       }
     }
   }
 
   void VisitArrayLiteral(ArrayLiteral* expr) { UNREACHABLE(); }
 
   void LoadInitFunction() {
     current_function_builder_ = init_function_;
     scope_ = kInitScope;
   }
@@ skipping 1148 matching lines @@
       for (int i = 0; i < static_cast<int>(arguments.size()); ++i) {
         LocalType type = TypeFrom(arguments[i]);
         DCHECK_NE(kAstStmt, type);
         b.AddParam(type);
       }
 
       WasmFunctionBuilder* function = builder_->AddFunction(b.Build());
       entry = functions_.LookupOrInsert(v, ComputePointerHash(v),
                                         ZoneAllocationPolicy(zone()));
       function->SetName(
-          reinterpret_cast<const char*>(v->raw_name()->raw_data()),
-          v->raw_name()->length());
+          {reinterpret_cast<const char*>(v->raw_name()->raw_data()),
+           v->raw_name()->length()});
       entry->value = function;
     }
     return (reinterpret_cast<WasmFunctionBuilder*>(entry->value));
   }
 
   LocalType TypeOf(Expression* expr) { return TypeFrom(typer_->TypeOf(expr)); }
 
   LocalType TypeFrom(AsmType* type) {
     if (type->IsA(AsmType::Intish())) {
       return kAstI32;
@@ skipping 50 matching lines @@
   impl.builder_->WriteTo(*buffer);
   return buffer;
 }
 
 const char* AsmWasmBuilder::foreign_init_name = "__foreign_init__";
 const char* AsmWasmBuilder::single_function_name = "__single_function__";
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8