Google Git
Sign in
android/platform/external/v8.git/refs/heads/android10-dev/./src/torque/implementation-visitor.cc
blob: 5044d914db30ca0e39c944e89cbd1ae14ac80a66 [file] [log] [blame] [edit]
// Copyright 2017 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 <algorithm>
#include "src/torque/implementation-visitor.h"
#include "src/torque/parameter-difference.h"
namespace v8 {
namespace internal {
namespace torque {
VisitResult ImplementationVisitor::Visit(Expression* expr) {
CurrentSourcePosition::Scope scope(expr->pos);
switch (expr->kind) {
#define ENUM_ITEM(name) \
case AstNode::Kind::k##name: \
return Visit(name::cast(expr));
AST_EXPRESSION_NODE_KIND_LIST(ENUM_ITEM)
#undef ENUM_ITEM
default:
UNREACHABLE();
}
}
const Type* ImplementationVisitor::Visit(Statement* stmt) {
CurrentSourcePosition::Scope scope(stmt->pos);
GenerateIndent();
source_out() << "// " << CurrentPositionAsString() << "\n";
switch (stmt->kind) {
#define ENUM_ITEM(name) \
case AstNode::Kind::k##name: \
return Visit(name::cast(stmt));
AST_STATEMENT_NODE_KIND_LIST(ENUM_ITEM)
#undef ENUM_ITEM
default:
UNIMPLEMENTED();
}
UNREACHABLE();
return nullptr;
}
void ImplementationVisitor::Visit(Declaration* decl) {
CurrentSourcePosition::Scope scope(decl->pos);
switch (decl->kind) {
#define ENUM_ITEM(name) \
case AstNode::Kind::k##name: \
return Visit(name::cast(decl));
AST_DECLARATION_NODE_KIND_LIST(ENUM_ITEM)
#undef ENUM_ITEM
default:
UNIMPLEMENTED();
}
}
void ImplementationVisitor::Visit(CallableNode* decl,
const Signature& signature, Statement* body) {
switch (decl->kind) {
#define ENUM_ITEM(name) \
case AstNode::Kind::k##name: \
return Visit(name::cast(decl), signature, body);
AST_CALLABLE_NODE_KIND_LIST(ENUM_ITEM)
#undef ENUM_ITEM
default:
UNIMPLEMENTED();
}
}
void ImplementationVisitor::BeginModuleFile(Module* module) {
std::ostream& source = module->source_stream();
std::ostream& header = module->header_stream();
if (module->IsDefault()) {
source << "#include \"src/code-stub-assembler.h\"";
} else {
source << "#include \"src/builtins/builtins-" +
DashifyString(module->name()) + "-gen.h\"";
}
source << "\n";
source << "#include \"src/builtins/builtins-utils-gen.h\"\n";
source << "#include \"src/builtins/builtins.h\"\n";
source << "#include \"src/code-factory.h\"\n";
source << "#include \"src/elements-kind.h\"\n";
source << "#include \"src/heap/factory-inl.h\"\n";
source << "#include \"src/objects.h\"\n";
source << "#include \"src/objects/bigint.h\"\n";
source << "#include \"builtins-" + DashifyString(module->name()) +
"-from-dsl-gen.h\"\n\n";
source << "namespace v8 {\n"
<< "namespace internal {\n"
<< "\n"
<< "using Node = compiler::Node;\n"
<< "\n";
std::string upper_name(module->name());
transform(upper_name.begin(), upper_name.end(), upper_name.begin(),
::toupper);
std::string headerDefine =
std::string("V8_TORQUE_") + upper_name + "_FROM_DSL_BASE_H__";
header << "#ifndef " << headerDefine << "\n";
header << "#define " << headerDefine << "\n\n";
if (module->IsDefault()) {
header << "#include \"src/code-stub-assembler.h\"";
} else {
header << "#include \"src/builtins/builtins-" +
DashifyString(module->name()) + "-gen.h\"\n";
}
header << "\n\n ";
header << "namespace v8 {\n"
<< "namespace internal {\n"
<< "\n";
header << "class " << GetDSLAssemblerName(module) << ": public "
<< GetBaseAssemblerName(module) << " {\n";
header << " public:\n";
header << " explicit " << GetDSLAssemblerName(module)
<< "(compiler::CodeAssemblerState* state) : "
<< GetBaseAssemblerName(module) << "(state) {}\n";
header << "\n";
header << " using Node = compiler::Node;\n";
header << " template <class T>\n";
header << " using TNode = compiler::TNode<T>;\n";
header << " template <class T>\n";
header << " using SloppyTNode = compiler::SloppyTNode<T>;\n\n";
}
void ImplementationVisitor::EndModuleFile(Module* module) {
std::ostream& source = module->source_stream();
std::ostream& header = module->header_stream();
DrainSpecializationQueue();
std::string upper_name(module->name());
transform(upper_name.begin(), upper_name.end(), upper_name.begin(),
::toupper);
std::string headerDefine =
std::string("V8_TORQUE_") + upper_name + "_FROM_DSL_BASE_H__";
source << "} // namespace internal\n"
<< "} // namespace v8\n"
<< "\n";
header << "};\n\n";
header << "} // namespace internal\n"
<< "} // namespace v8\n"
<< "\n";
header << "#endif // " << headerDefine << "\n";
}
void ImplementationVisitor::Visit(ModuleDeclaration* decl) {
Module* module = decl->GetModule();
Module* saved_module = module_;
module_ = module;
Declarations::ModuleScopeActivator scope(declarations(), decl->GetModule());
for (auto& child : decl->declarations) Visit(child);
module_ = saved_module;
}
void ImplementationVisitor::Visit(ConstDeclaration* decl) {
Signature signature = MakeSignatureFromReturnType(decl->type);
std::string name = decl->name;
header_out() << " ";
GenerateFunctionDeclaration(header_out(), "", name, signature, {});
header_out() << ";\n";
GenerateFunctionDeclaration(source_out(),
GetDSLAssemblerName(CurrentModule()) + "::", name,
signature, {});
source_out() << " {\n";
DCHECK(!signature.return_type->IsVoidOrNever());
VisitResult expression_result = Visit(decl->expression);
VisitResult return_result =
GenerateImplicitConvert(signature.return_type, expression_result);
GenerateIndent();
source_out() << "return " << return_result.RValue() << ";\n";
source_out() << "}\n\n";
}
void ImplementationVisitor::Visit(StructDeclaration* decl) {
header_out() << " struct " << decl->name << " {\n";
const StructType* struct_type =
static_cast<const StructType*>(declarations()->LookupType(decl->name));
for (auto& field : struct_type->fields()) {
header_out() << " " << field.type->GetGeneratedTypeName();
header_out() << " " << field.name << ";\n";
}
header_out() << " } "
<< ";\n";
}
void ImplementationVisitor::Visit(TorqueMacroDeclaration* decl,
const Signature& sig, Statement* body) {
Signature signature = MakeSignature(decl->signature.get());
std::string name = GetGeneratedCallableName(
decl->name, declarations()->GetCurrentSpecializationTypeNamesVector());
const TypeVector& list = signature.types();
Macro* macro = declarations()->LookupMacro(name, list);
CurrentCallableActivator activator(global_context_, macro, decl);
if (body != nullptr) {
header_out() << " ";
GenerateMacroFunctionDeclaration(header_out(), "", macro);
header_out() << ";\n";
GenerateMacroFunctionDeclaration(
source_out(), GetDSLAssemblerName(CurrentModule()) + "::", macro);
source_out() << " {\n";
const Variable* result_var = nullptr;
if (macro->HasReturnValue()) {
result_var =
GeneratePredeclaredVariableDeclaration(kReturnValueVariable, {});
}
Label* macro_end = declarations()->DeclareLabel("macro_end");
GenerateLabelDefinition(macro_end, decl);
const Type* result = Visit(body);
if (result->IsNever()) {
if (!macro->signature().return_type->IsNever() && !macro->HasReturns()) {
std::stringstream s;
s << "macro " << decl->name
<< " that never returns must have return type never";
ReportError(s.str());
}
} else {
if (macro->signature().return_type->IsNever()) {
std::stringstream s;
s << "macro " << decl->name
<< " has implicit return at end of its declartion but return type "
"never";
ReportError(s.str());
} else if (!macro->signature().return_type->IsVoid()) {
std::stringstream s;
s << "macro " << decl->name
<< " expects to return a value but doesn't on all paths";
ReportError(s.str());
}
}
if (macro->HasReturns()) {
if (!result->IsNever()) {
GenerateLabelGoto(macro_end);
}
GenerateLabelBind(macro_end);
}
if (result_var != nullptr) {
GenerateIndent();
source_out() << "return "
<< RValueFlattenStructs(
VisitResult(result_var->type(), result_var))
<< ";\n";
}
source_out() << "}\n\n";
}
}
void ImplementationVisitor::Visit(TorqueBuiltinDeclaration* decl,
const Signature& signature, Statement* body) {
std::string name = GetGeneratedCallableName(
decl->name, declarations()->GetCurrentSpecializationTypeNamesVector());
source_out() << "TF_BUILTIN(" << name << ", "
<< GetDSLAssemblerName(CurrentModule()) << ") {\n";
Builtin* builtin = declarations()->LookupBuiltin(name);
CurrentCallableActivator activator(global_context_, builtin, decl);
// Context
const Value* val =
declarations()->LookupValue(decl->signature->parameters.names[0]);
GenerateIndent();
source_out() << "TNode<Context> " << val->value()
<< " = UncheckedCast<Context>(Parameter("
<< "Descriptor::kContext));\n";
GenerateIndent();
source_out() << "USE(" << val->value() << ");\n";
size_t first = 1;
if (builtin->IsVarArgsJavaScript()) {
assert(decl->signature->parameters.has_varargs);
ExternConstant* arguments =
ExternConstant::cast(declarations()->LookupValue(
decl->signature->parameters.arguments_variable));
std::string arguments_name = arguments->value();
GenerateIndent();
source_out()
<< "Node* argc = Parameter(Descriptor::kJSActualArgumentsCount);\n";
GenerateIndent();
source_out() << "CodeStubArguments arguments_impl(this, "
"ChangeInt32ToIntPtr(argc));\n";
const Value* receiver =
declarations()->LookupValue(decl->signature->parameters.names[1]);
GenerateIndent();
source_out() << "TNode<Object> " << receiver->value()
<< " = arguments_impl.GetReceiver();\n";
GenerateIndent();
source_out() << "auto arguments = &arguments_impl;\n";
GenerateIndent();
source_out() << "USE(arguments);\n";
GenerateIndent();
source_out() << "USE(" << receiver->value() << ");\n";
first = 2;
}
GenerateParameterList(decl->signature->parameters.names, first);
Visit(body);
source_out() << "}\n\n";
}
const Type* ImplementationVisitor::Visit(VarDeclarationStatement* stmt) {
base::Optional<VisitResult> init_result;
if (stmt->initializer) {
init_result = Visit(*stmt->initializer);
}
base::Optional<const Type*> type;
if (stmt->type) type = declarations()->GetType(*stmt->type);
GenerateVariableDeclaration(stmt, stmt->name, stmt->const_qualified, type,
init_result);
return TypeOracle::GetVoidType();
}
const Type* ImplementationVisitor::Visit(TailCallStatement* stmt) {
return Visit(stmt->call, true).type();
}
VisitResult ImplementationVisitor::Visit(ConditionalExpression* expr) {
std::string f1 = NewTempVariable();
std::string f2 = NewTempVariable();
// The code for both paths of the conditional need to be generated first in
// lambdas before evaluating the conditional expression because the common
// type of the result of both the true and false of the condition needs to be
// known when declaring the variable to hold the result of the conditional.
VisitResult left, right;
GenerateIndent();
source_out() << "auto " << f1 << " = [=]() ";
{
ScopedIndent indent(this, false);
source_out() << "\n";
left = Visit(expr->if_true);
GenerateIndent();
source_out() << "return " << RValueFlattenStructs(left) << ";\n";
}
source_out() << ";\n";
GenerateIndent();
source_out() << "auto " << f2 << " = [=]() ";
{
ScopedIndent indent(this, false);
source_out() << "\n";
right = Visit(expr->if_false);
GenerateIndent();
source_out() << "return " << RValueFlattenStructs(right) << ";\n";
}
source_out() << ";\n";
const Type* common_type = GetCommonType(left.type(), right.type());
std::string result_var = NewTempVariable();
Variable* result =
GenerateVariableDeclaration(expr, result_var, false, common_type);
{
ScopedIndent indent(this);
Declarations::NodeScopeActivator scope(declarations(), expr->condition);
Label* true_label = declarations()->LookupLabel(kTrueLabelName);
GenerateLabelDefinition(true_label);
Label* false_label = declarations()->LookupLabel(kFalseLabelName);
GenerateLabelDefinition(false_label);
Label* done_label = declarations()->DeclarePrivateLabel(kDoneLabelName);
GenerateLabelDefinition(done_label, expr);
VisitResult condition_result = Visit(expr->condition);
if (!condition_result.type()->IsNever()) {
condition_result =
GenerateImplicitConvert(TypeOracle::GetBoolType(), condition_result);
GenerateBranch(condition_result, true_label, false_label);
}
GenerateLabelBind(true_label);
GenerateIndent();
VisitResult left_result = {right.type(), f1 + "()"};
GenerateAssignToVariable(result, left_result);
GenerateLabelGoto(done_label);
GenerateLabelBind(false_label);
GenerateIndent();
VisitResult right_result = {right.type(), f2 + "()"};
GenerateAssignToVariable(result, right_result);
GenerateLabelGoto(done_label);
GenerateLabelBind(done_label);
}
return VisitResult(common_type, result);
}
VisitResult ImplementationVisitor::Visit(LogicalOrExpression* expr) {
VisitResult left_result;
{
Declarations::NodeScopeActivator scope(declarations(), expr->left);
Label* false_label = declarations()->LookupLabel(kFalseLabelName);
GenerateLabelDefinition(false_label);
left_result = Visit(expr->left);
if (left_result.type()->IsBool()) {
Label* true_label = declarations()->LookupLabel(kTrueLabelName);
GenerateIndent();
source_out() << "GotoIf(" << RValueFlattenStructs(left_result) << ", "
<< true_label->generated() << ");\n";
} else if (!left_result.type()->IsConstexprBool()) {
GenerateLabelBind(false_label);
}
}
VisitResult right_result = Visit(expr->right);
if (right_result.type() != left_result.type()) {
std::stringstream stream;
stream << "types of left and right expression of logical OR don't match (\""
<< *left_result.type() << "\" vs. \"" << *right_result.type()
<< "\")";
ReportError(stream.str());
}
if (left_result.type()->IsConstexprBool()) {
return VisitResult(left_result.type(),
std::string("(") + RValueFlattenStructs(left_result) +
" || " + RValueFlattenStructs(right_result) + ")");
} else {
return right_result;
}
}
VisitResult ImplementationVisitor::Visit(LogicalAndExpression* expr) {
VisitResult left_result;
{
Declarations::NodeScopeActivator scope(declarations(), expr->left);
Label* true_label = declarations()->LookupLabel(kTrueLabelName);
GenerateLabelDefinition(true_label);
left_result = Visit(expr->left);
if (left_result.type()->IsBool()) {
Label* false_label = declarations()->LookupLabel(kFalseLabelName);
GenerateIndent();
source_out() << "GotoIfNot(" << RValueFlattenStructs(left_result) << ", "
<< false_label->generated() << ");\n";
} else if (!left_result.type()->IsConstexprBool()) {
GenerateLabelBind(true_label);
}
}
VisitResult right_result = Visit(expr->right);
if (right_result.type() != left_result.type()) {
std::stringstream stream;
stream
<< "types of left and right expression of logical AND don't match (\""
<< *left_result.type() << "\" vs. \"" << *right_result.type() << "\")";
ReportError(stream.str());
}
if (left_result.type()->IsConstexprBool()) {
return VisitResult(left_result.type(),
std::string("(") + RValueFlattenStructs(left_result) +
" && " + RValueFlattenStructs(right_result) + ")");
} else {
return right_result;
}
}
VisitResult ImplementationVisitor::Visit(IncrementDecrementExpression* expr) {
VisitResult value_copy;
auto location_ref = GetLocationReference(expr->location);
VisitResult current_value =
GenerateFetchFromLocation(expr->location, location_ref);
if (expr->postfix) {
value_copy = GenerateCopy(current_value);
}
VisitResult one = {TypeOracle::GetConstInt31Type(), "1"};
Arguments args;
args.parameters = {current_value, one};
VisitResult assignment_value = GenerateCall(
expr->op == IncrementDecrementOperator::kIncrement ? "+" : "-", args);
GenerateAssignToLocation(expr->location, location_ref, assignment_value);
return expr->postfix ? value_copy : assignment_value;
}
VisitResult ImplementationVisitor::Visit(AssignmentExpression* expr) {
LocationReference location_ref = GetLocationReference(expr->location);
VisitResult assignment_value;
if (expr->op) {
VisitResult location_value =
GenerateFetchFromLocation(expr->location, location_ref);
assignment_value = Visit(expr->value);
Arguments args;
args.parameters = {location_value, assignment_value};
assignment_value = GenerateCall(*expr->op, args);
GenerateAssignToLocation(expr->location, location_ref, assignment_value);
} else {
assignment_value = Visit(expr->value);
GenerateAssignToLocation(expr->location, location_ref, assignment_value);
}
return assignment_value;
}
VisitResult ImplementationVisitor::Visit(NumberLiteralExpression* expr) {
// TODO(tebbi): Do not silently loose precision; support 64bit literals.
double d = std::stod(expr->number.c_str());
int32_t i = static_cast<int32_t>(d);
const Type* result_type =
declarations()->LookupType(CONST_FLOAT64_TYPE_STRING);
if (i == d) {
if ((i >> 30) == (i >> 31)) {
result_type = declarations()->LookupType(CONST_INT31_TYPE_STRING);
} else {
result_type = declarations()->LookupType(CONST_INT32_TYPE_STRING);
}
}
std::string temp = GenerateNewTempVariable(result_type);
source_out() << expr->number << ";\n";
return VisitResult{result_type, temp};
}
VisitResult ImplementationVisitor::Visit(AssumeTypeImpossibleExpression* expr) {
VisitResult result = Visit(expr->expression);
const Type* result_type =
SubtractType(result.type(), declarations()->GetType(expr->excluded_type));
if (result_type->IsNever()) {
ReportError("unreachable code");
}
return VisitResult{result_type, "UncheckedCast<" +
result_type->GetGeneratedTNodeTypeName() +
">(" + result.RValue() + ")"};
}
VisitResult ImplementationVisitor::Visit(StringLiteralExpression* expr) {
std::string temp = GenerateNewTempVariable(TypeOracle::GetConstStringType());
source_out() << "\"" << expr->literal.substr(1, expr->literal.size() - 2)
<< "\";\n";
return VisitResult{TypeOracle::GetConstStringType(), temp};
}
VisitResult ImplementationVisitor::GetBuiltinCode(Builtin* builtin) {
if (builtin->IsExternal() || builtin->kind() != Builtin::kStub) {
ReportError(
"creating function pointers is only allowed for internal builtins with "
"stub linkage");
}
const Type* type = TypeOracle::GetFunctionPointerType(
builtin->signature().parameter_types.types,
builtin->signature().return_type);
std::string code =
"HeapConstant(Builtins::CallableFor(isolate(), Builtins::k" +
builtin->name() + ").code())";
return VisitResult(type, code);
}
VisitResult ImplementationVisitor::Visit(IdentifierExpression* expr) {
std::string name = expr->name;
if (expr->generic_arguments.size() != 0) {
GenericList* generic_list = declarations()->LookupGeneric(expr->name);
for (Generic* generic : generic_list->list()) {
TypeVector specialization_types = GetTypeVector(expr->generic_arguments);
name = GetGeneratedCallableName(name, specialization_types);
CallableNode* callable = generic->declaration()->callable;
QueueGenericSpecialization({generic, specialization_types}, callable,
callable->signature.get(),
generic->declaration()->body);
}
}
if (Builtin* builtin = Builtin::DynamicCast(declarations()->Lookup(name))) {
return GetBuiltinCode(builtin);
}
return GenerateFetchFromLocation(expr, GetLocationReference(expr));
}
const Type* ImplementationVisitor::Visit(GotoStatement* stmt) {
Label* label = declarations()->LookupLabel(stmt->label);
if (stmt->arguments.size() != label->GetParameterCount()) {
std::stringstream stream;
stream << "goto to label has incorrect number of parameters (expected "
<< std::to_string(label->GetParameterCount()) << " found "
<< std::to_string(stmt->arguments.size()) << ")";
ReportError(stream.str());
}
size_t i = 0;
for (Expression* e : stmt->arguments) {
VisitResult result = Visit(e);
Variable* var = label->GetParameter(i++);
GenerateAssignToVariable(var, result);
}
GenerateLabelGoto(label);
label->MarkUsed();
return TypeOracle::GetNeverType();
}
const Type* ImplementationVisitor::Visit(IfStatement* stmt) {
ScopedIndent indent(this);
bool has_else = stmt->if_false.has_value();
if (stmt->is_constexpr) {
VisitResult expression_result = Visit(stmt->condition);
if (!(expression_result.type() == TypeOracle::GetConstexprBoolType())) {
std::stringstream stream;
stream << "expression should return type constexpr bool "
<< "but returns type " << *expression_result.type();
ReportError(stream.str());
}
const Type* left_result;
const Type* right_result = TypeOracle::GetVoidType();
{
GenerateIndent();
source_out() << "if ((" << RValueFlattenStructs(expression_result)
<< ")) ";
ScopedIndent indent(this, false);
source_out() << "\n";
left_result = Visit(stmt->if_true);
}
if (has_else) {
source_out() << " else ";
ScopedIndent indent(this, false);
source_out() << "\n";
right_result = Visit(*stmt->if_false);
}
if (left_result->IsNever() != right_result->IsNever()) {
std::stringstream stream;
stream << "either both or neither branches in a constexpr if statement "
"must reach their end at"
<< PositionAsString(stmt->pos);
ReportError(stream.str());
}
source_out() << "\n";
return left_result;
} else {
Label* true_label = nullptr;
Label* false_label = nullptr;
{
Declarations::NodeScopeActivator scope(declarations(), &*stmt->condition);
true_label = declarations()->LookupLabel(kTrueLabelName);
GenerateLabelDefinition(true_label);
false_label = declarations()->LookupLabel(kFalseLabelName);
GenerateLabelDefinition(false_label, !has_else ? stmt : nullptr);
}
Label* done_label = nullptr;
bool live = false;
if (has_else) {
done_label = declarations()->DeclarePrivateLabel("if_done_label");
GenerateLabelDefinition(done_label, stmt);
} else {
done_label = false_label;
live = true;
}
std::vector<Statement*> blocks = {stmt->if_true};
std::vector<Label*> labels = {true_label, false_label};
if (has_else) blocks.push_back(*stmt->if_false);
if (GenerateExpressionBranch(stmt->condition, labels, blocks, done_label)) {
live = true;
}
if (live) {
GenerateLabelBind(done_label);
}
return live ? TypeOracle::GetVoidType() : TypeOracle::GetNeverType();
}
}
const Type* ImplementationVisitor::Visit(WhileStatement* stmt) {
ScopedIndent indent(this);
Label* body_label = nullptr;
Label* exit_label = nullptr;
{
Declarations::NodeScopeActivator scope(declarations(), stmt->condition);
body_label = declarations()->LookupLabel(kTrueLabelName);
GenerateLabelDefinition(body_label);
exit_label = declarations()->LookupLabel(kFalseLabelName);
GenerateLabelDefinition(exit_label);
}
Label* header_label = declarations()->DeclarePrivateLabel("header");
GenerateLabelDefinition(header_label, stmt);
GenerateLabelGoto(header_label);
GenerateLabelBind(header_label);
Declarations::NodeScopeActivator scope(declarations(), stmt->body);
BreakContinueActivator activator(global_context_, exit_label, header_label);
GenerateExpressionBranch(stmt->condition, {body_label, exit_label},
{stmt->body}, header_label);
GenerateLabelBind(exit_label);
return TypeOracle::GetVoidType();
}
const Type* ImplementationVisitor::Visit(BlockStatement* block) {
Declarations::NodeScopeActivator scope(declarations(), block);
ScopedIndent indent(this);
const Type* type = TypeOracle::GetVoidType();
for (Statement* s : block->statements) {
if (type->IsNever()) {
std::stringstream stream;
stream << "statement after non-returning statement";
ReportError(stream.str());
}
type = Visit(s);
}
return type;
}
const Type* ImplementationVisitor::Visit(DebugStatement* stmt) {
#if defined(DEBUG)
GenerateIndent();
source_out() << "Print(\""
<< "halting because of '" << stmt->reason << "' at "
<< PositionAsString(stmt->pos) << "\");\n";
#endif
GenerateIndent();
if (stmt->never_continues) {
source_out() << "Unreachable();\n";
return TypeOracle::GetNeverType();
} else {
source_out() << "DebugBreak();\n";
return TypeOracle::GetVoidType();
}
}
namespace {
std::string FormatAssertSource(const std::string& str) {
// Replace all whitespace characters with a space character.
std::string str_no_newlines = str;
std::replace_if(str_no_newlines.begin(), str_no_newlines.end(),
[](unsigned char c) { return isspace(c); }, ' ');
// str might include indentation, squash multiple space characters into one.
std::string result;
std::unique_copy(str_no_newlines.begin(), str_no_newlines.end(),
std::back_inserter(result),
[](char a, char b) { return a == ' ' && b == ' '; });
return result;
}
} // namespace
const Type* ImplementationVisitor::Visit(AssertStatement* stmt) {
bool do_check = !stmt->debug_only;
#if defined(DEBUG)
do_check = true;
#endif
if (do_check) {
// CSA_ASSERT & co. are not used here on purpose for two reasons. First,
// Torque allows and handles two types of expressions in the if protocol
// automagically, ones that return TNode<BoolT> and those that use the
// BranchIf(..., Label* true, Label* false) idiom. Because the machinery to
// handle this is embedded in the expression handling and to it's not
// possible to make the decision to use CSA_ASSERT or CSA_ASSERT_BRANCH
// isn't trivial up-front. Secondly, on failure, the assert text should be
// the corresponding Torque code, not the -gen.cc code, which would be the
// case when using CSA_ASSERT_XXX.
Label* true_label = nullptr;
Label* false_label = nullptr;
Declarations::NodeScopeActivator scope(declarations(), stmt->expression);
true_label = declarations()->LookupLabel(kTrueLabelName);
GenerateLabelDefinition(true_label);
false_label = declarations()->LookupLabel(kFalseLabelName);
GenerateLabelDefinition(false_label);
VisitResult expression_result = Visit(stmt->expression);
if (expression_result.type() == TypeOracle::GetBoolType()) {
GenerateBranch(expression_result, true_label, false_label);
} else {
if (expression_result.type() != TypeOracle::GetNeverType()) {
std::stringstream s;
s << "unexpected return type " << *expression_result.type()
<< " for branch expression";
ReportError(s.str());
}
}
GenerateLabelBind(false_label);
GenerateIndent();
source_out() << "Print(\""
<< "assert '" << FormatAssertSource(stmt->source)
<< "' failed at " << PositionAsString(stmt->pos) << "\");\n";
GenerateIndent();
source_out() << "Unreachable();\n";
GenerateLabelBind(true_label);
}
return TypeOracle::GetVoidType();
}
const Type* ImplementationVisitor::Visit(ExpressionStatement* stmt) {
const Type* type = Visit(stmt->expression).type();
return type->IsNever() ? type : TypeOracle::GetVoidType();
}
const Type* ImplementationVisitor::Visit(ReturnStatement* stmt) {
Callable* current_callable = global_context_.GetCurrentCallable();
if (current_callable->signature().return_type->IsNever()) {
std::stringstream s;
s << "cannot return from a function with return type never";
ReportError(s.str());
}
Label* end = current_callable->IsMacro()
? declarations()->LookupLabel("macro_end")
: nullptr;
if (current_callable->HasReturnValue()) {
if (!stmt->value) {
std::stringstream s;
s << "return expression needs to be specified for a return type of "
<< *current_callable->signature().return_type;
ReportError(s.str());
}
VisitResult expression_result = Visit(*stmt->value);
VisitResult return_result = GenerateImplicitConvert(
current_callable->signature().return_type, expression_result);
if (current_callable->IsMacro()) {
Variable* var =
Variable::cast(declarations()->LookupValue(kReturnValueVariable));
GenerateAssignToVariable(var, return_result);
GenerateLabelGoto(end);
} else if (current_callable->IsBuiltin()) {
if (Builtin::cast(current_callable)->IsVarArgsJavaScript()) {
GenerateIndent();
source_out() << "arguments->PopAndReturn("
<< RValueFlattenStructs(return_result) << ");\n";
} else {
GenerateIndent();
source_out() << "Return(" << RValueFlattenStructs(return_result)
<< ");\n";
}
} else {
UNREACHABLE();
}
} else {
if (stmt->value) {
std::stringstream s;
s << "return expression can't be specified for a void or never return "
"type";
ReportError(s.str());
}
GenerateLabelGoto(end);
}
current_callable->IncrementReturns();
return TypeOracle::GetNeverType();
}
const Type* ImplementationVisitor::Visit(ForOfLoopStatement* stmt) {
Declarations::NodeScopeActivator scope(declarations(), stmt);
VisitResult expression_result = Visit(stmt->iterable);
VisitResult begin = stmt->begin
? Visit(*stmt->begin)
: VisitResult(TypeOracle::GetConstInt31Type(), "0");
VisitResult end = stmt->end
? Visit(*stmt->end)
: GenerateCall(".length", {{expression_result}, {}});
Label* body_label = declarations()->DeclarePrivateLabel("body");
GenerateLabelDefinition(body_label);
Label* increment_label = declarations()->DeclarePrivateLabel("increment");
GenerateLabelDefinition(increment_label);
Label* exit_label = declarations()->DeclarePrivateLabel("exit");
GenerateLabelDefinition(exit_label);
const Type* common_type = GetCommonType(begin.type(), end.type());
Variable* index_var = GenerateVariableDeclaration(
stmt, std::string(kForIndexValueVariable) + "_" + NewTempVariable(),
false, common_type, begin);
VisitResult index_for_read = {index_var->type(), index_var};
Label* header_label = declarations()->DeclarePrivateLabel("header");
GenerateLabelDefinition(header_label, stmt);
GenerateLabelGoto(header_label);
GenerateLabelBind(header_label);
BreakContinueActivator activator(global_context_, exit_label,
increment_label);
VisitResult result = GenerateCall("<", {{index_for_read, end}, {}});
GenerateBranch(result, body_label, exit_label);
GenerateLabelBind(body_label);
VisitResult element_result =
GenerateCall("[]", {{expression_result, index_for_read}, {}});
base::Optional<const Type*> declared_type;
if (stmt->var_declaration->type)
declared_type = declarations()->GetType(*stmt->var_declaration->type);
GenerateVariableDeclaration(
stmt->var_declaration, stmt->var_declaration->name,
stmt->var_declaration->const_qualified, declared_type, element_result);
Visit(stmt->body);
GenerateLabelGoto(increment_label);
GenerateLabelBind(increment_label);
Arguments increment_args;
increment_args.parameters = {index_for_read,
{TypeOracle::GetConstInt31Type(), "1"}};
VisitResult increment_result = GenerateCall("+", increment_args);
GenerateAssignToVariable(index_var, increment_result);
GenerateLabelGoto(header_label);
GenerateLabelBind(exit_label);
return TypeOracle::GetVoidType();
}
const Type* ImplementationVisitor::Visit(TryLabelStatement* stmt) {
ScopedIndent indent(this);
Label* try_done = declarations()->DeclarePrivateLabel("try_done");
GenerateLabelDefinition(try_done);
const Type* try_result = TypeOracle::GetNeverType();
std::vector<Label*> labels;
// Output labels for the goto handlers and for the merge after the try.
{
// Activate a new scope to see handler labels
Declarations::NodeScopeActivator scope(declarations(), stmt);
for (LabelBlock* block : stmt->label_blocks) {
CurrentSourcePosition::Scope scope(block->pos);
Label* label = declarations()->LookupLabel(block->label);
labels.push_back(label);
GenerateLabelDefinition(label);
}
size_t i = 0;
for (auto label : labels) {
Declarations::NodeScopeActivator scope(declarations(),
stmt->label_blocks[i]->body);
for (auto& v : label->GetParameters()) {
GenerateVariableDeclaration(stmt, v->name(), false, v->type());
v->Define();
}
++i;
}
Label* try_begin_label = declarations()->DeclarePrivateLabel("try_begin");
GenerateLabelDefinition(try_begin_label);
GenerateLabelGoto(try_begin_label);
// Visit try
if (GenerateLabeledStatementBlocks({stmt->try_block},
std::vector<Label*>({try_begin_label}),
try_done)) {
try_result = TypeOracle::GetVoidType();
}
}
// Make sure that each label clause is actually used. It's not just a friendly
// thing to do, it will cause problems downstream in the compiler if there are
// bound labels that are never jumped to.
auto label_iterator = stmt->label_blocks.begin();
for (auto label : labels) {
CurrentSourcePosition::Scope scope((*label_iterator)->pos);
if (!label->IsUsed()) {
std::stringstream s;
s << "label ";
s << (*label_iterator)->label;
s << " has a handler block but is never referred to in try block";
ReportError(s.str());
}
label_iterator++;
}
// Visit and output the code for each catch block, one-by-one.
std::vector<Statement*> bodies;
for (LabelBlock* block : stmt->label_blocks) bodies.push_back(block->body);
if (GenerateLabeledStatementBlocks(bodies, labels, try_done)) {
try_result = TypeOracle::GetVoidType();
}
if (!try_result->IsNever()) {
GenerateLabelBind(try_done);
}
return try_result;
}
const Type* ImplementationVisitor::Visit(BreakStatement* stmt) {
Label* break_label = global_context_.GetCurrentBreak();
if (break_label == nullptr) {
ReportError("break used outside of loop");
}
GenerateLabelGoto(break_label);
return TypeOracle::GetNeverType();
}
const Type* ImplementationVisitor::Visit(ContinueStatement* stmt) {
Label* continue_label = global_context_.GetCurrentContinue();
if (continue_label == nullptr) {
ReportError("continue used outside of loop");
}
GenerateLabelGoto(continue_label);
return TypeOracle::GetNeverType();
}
const Type* ImplementationVisitor::Visit(ForLoopStatement* stmt) {
Declarations::NodeScopeActivator scope(declarations(), stmt);
if (stmt->var_declaration) Visit(*stmt->var_declaration);
Label* body_label = declarations()->LookupLabel(kTrueLabelName);
GenerateLabelDefinition(body_label);
Label* exit_label = declarations()->LookupLabel(kFalseLabelName);
GenerateLabelDefinition(exit_label);
Label* header_label = declarations()->DeclarePrivateLabel("header");
GenerateLabelDefinition(header_label, stmt);
GenerateLabelGoto(header_label);
GenerateLabelBind(header_label);
// The continue label is where "continue" statements jump to. If no action
// expression is provided, we jump directly to the header.
Label* continue_label = header_label;
// The action label is only needed when an action expression was provided.
Label* action_label = nullptr;
if (stmt->action) {
action_label = declarations()->DeclarePrivateLabel("action");
GenerateLabelDefinition(action_label);
// The action expression needs to be executed on a continue.
continue_label = action_label;
}
BreakContinueActivator activator(global_context_, exit_label, continue_label);
std::vector<Label*> labels = {body_label, exit_label};
bool generate_action = true;
if (stmt->test) {
generate_action = GenerateExpressionBranch(*stmt->test, labels,
{stmt->body}, continue_label);
} else {
GenerateLabelGoto(body_label);
generate_action =
GenerateLabeledStatementBlocks({stmt->body}, labels, continue_label);
}
if (generate_action && stmt->action) {
ScopedIndent indent(this);
GenerateLabelBind(action_label);
Visit(*stmt->action);
GenerateLabelGoto(header_label);
}
GenerateLabelBind(exit_label);
return TypeOracle::GetVoidType();
}
void ImplementationVisitor::GenerateImplementation(const std::string& dir,
Module* module) {
std::string new_source(module->source());
std::string base_file_name =
"builtins-" + DashifyString(module->name()) + "-from-dsl-gen";
std::string source_file_name = dir + "/" + base_file_name + ".cc";
ReplaceFileContentsIfDifferent(source_file_name, new_source);
std::string new_header(module->header());
std::string header_file_name = dir + "/" + base_file_name + ".h";
ReplaceFileContentsIfDifferent(header_file_name, new_header);
}
std::string ImplementationVisitor::GetBaseAssemblerName(Module* module) {
if (module == global_context_.GetDefaultModule()) {
return "CodeStubAssembler";
} else {
std::string assembler_name(CamelifyString(module->name()) +
"BuiltinsAssembler");
return assembler_name;
}
}
std::string ImplementationVisitor::GetDSLAssemblerName(Module* module) {
std::string assembler_name(CamelifyString(module->name()) +
"BuiltinsFromDSLAssembler");
return assembler_name;
}
void ImplementationVisitor::GenerateIndent() {
for (size_t i = 0; i <= indent_; ++i) {
source_out() << " ";
}
}
void ImplementationVisitor::GenerateMacroFunctionDeclaration(
std::ostream& o, const std::string& macro_prefix, Macro* macro) {
GenerateFunctionDeclaration(o, macro_prefix, macro->name(),
macro->signature(), macro->parameter_names());
}
void ImplementationVisitor::GenerateFunctionDeclaration(
std::ostream& o, const std::string& macro_prefix, const std::string& name,
const Signature& signature, const NameVector& parameter_names) {
if (global_context_.verbose()) {
std::cout << "generating source for declaration " << name << "\n";
}
// Quite a hack here. Make sure that TNode is namespace qualified if the
// macro/constant name is also qualified.
std::string return_type_name(signature.return_type->GetGeneratedTypeName());
if (const StructType* struct_type =
StructType::DynamicCast(signature.return_type)) {
o << GetDSLAssemblerName(struct_type->module()) << "::";
} else if (macro_prefix != "" && (return_type_name.length() > 5) &&
(return_type_name.substr(0, 5) == "TNode")) {
o << "compiler::";
}
o << return_type_name;
o << " " << macro_prefix << name << "(";
DCHECK_EQ(signature.types().size(), parameter_names.size());
auto type_iterator = signature.types().begin();
bool first = true;
for (const std::string& name : parameter_names) {
if (!first) {
o << ", ";
}
const Value* parameter = declarations()->LookupValue(name);
const Type* parameter_type = *type_iterator;
const std::string& generated_type_name =
parameter_type->GetGeneratedTypeName();
o << generated_type_name << " " << parameter->value();
type_iterator++;
first = false;
}
for (const LabelDeclaration& label_info : signature.labels) {
Label* label = declarations()->LookupLabel(label_info.name);
if (!first) {
o << ", ";
}
o << "Label* " << label->generated();
for (Variable* var : label->GetParameters()) {
std::string generated_type_name("TVariable<");
generated_type_name += var->type()->GetGeneratedTNodeTypeName();
generated_type_name += ">*";
o << ", ";
o << generated_type_name << " " << var->value();
}
}
o << ")";
}
namespace {
void PrintMacroSignatures(std::stringstream& s, const std::string& name,
const std::vector<Macro*>& macros) {
for (Macro* m : macros) {
s << "\n " << name;
PrintSignature(s, m->signature(), false);
}
}
void FailMacroLookup(const std::string& reason, const std::string& name,
const Arguments& arguments,
const std::vector<Macro*>& candidates) {
std::stringstream stream;
stream << "\n"
<< reason << ": \n " << name << "("
<< arguments.parameters.GetTypeVector() << ")";
if (arguments.labels.size() != 0) {
stream << " labels ";
for (auto l : arguments.labels) {
PrintLabel(stream, *l, false);
}
}
stream << "\ncandidates are:";
PrintMacroSignatures(stream, name, candidates);
ReportError(stream.str());
}
} // namespace
Callable* ImplementationVisitor::LookupCall(
const std::string& name, const Arguments& arguments,
const TypeVector& specialization_types) {
Callable* result = nullptr;
TypeVector parameter_types(arguments.parameters.GetTypeVector());
bool has_template_arguments = !specialization_types.empty();
std::string mangled_name = name;
if (has_template_arguments) {
mangled_name = GetGeneratedCallableName(name, specialization_types);
}
Declarable* declarable = declarations()->Lookup(mangled_name);
if (declarable->IsBuiltin()) {
result = Builtin::cast(declarable);
} else if (declarable->IsRuntimeFunction()) {
result = RuntimeFunction::cast(declarable);
} else if (declarable->IsMacroList()) {
std::vector<Macro*> candidates;
std::vector<Macro*> macros_with_same_name;
for (Macro* m : MacroList::cast(declarable)->list()) {
bool try_bool_context =
arguments.labels.size() == 0 &&
m->signature().return_type == TypeOracle::GetNeverType();
Label* true_label = nullptr;
Label* false_label = nullptr;
if (try_bool_context) {
true_label = declarations()->TryLookupLabel(kTrueLabelName);
false_label = declarations()->TryLookupLabel(kFalseLabelName);
}
if (IsCompatibleSignature(m->signature(), parameter_types,
arguments.labels) ||
(true_label && false_label &&
IsCompatibleSignature(m->signature(), parameter_types,
{true_label, false_label}))) {
candidates.push_back(m);
} else {
macros_with_same_name.push_back(m);
}
}
if (candidates.empty() && macros_with_same_name.empty()) {
std::stringstream stream;
stream << "no matching declaration found for " << name;
ReportError(stream.str());
} else if (candidates.empty()) {
FailMacroLookup("cannot find macro with name", name, arguments,
macros_with_same_name);
}
auto is_better_candidate = [&](Macro* a, Macro* b) {
return ParameterDifference(a->signature().parameter_types.types,
parameter_types)
.StrictlyBetterThan(ParameterDifference(
b->signature().parameter_types.types, parameter_types));
};
Macro* best = *std::min_element(candidates.begin(), candidates.end(),
is_better_candidate);
for (Macro* candidate : candidates) {
if (candidate != best && !is_better_candidate(best, candidate)) {
FailMacroLookup("ambiguous macro", name, arguments, candidates);
}
}
result = best;
} else {
std::stringstream stream;
stream << "can't call " << declarable->type_name() << " " << name
<< " because it's not callable"
<< ": call parameters were (" << parameter_types << ")";
ReportError(stream.str());
}
size_t caller_size = parameter_types.size();
size_t callee_size = result->signature().types().size();
if (caller_size != callee_size &&
!result->signature().parameter_types.var_args) {
std::stringstream stream;
stream << "parameter count mismatch calling " << *result << " - expected "
<< std::to_string(callee_size) << ", found "
<< std::to_string(caller_size);
ReportError(stream.str());
}
if (has_template_arguments) {
Generic* generic = *result->generic();
CallableNode* callable = generic->declaration()->callable;
if (generic->declaration()->body) {
QueueGenericSpecialization({generic, specialization_types}, callable,
callable->signature.get(),
generic->declaration()->body);
}
}
return result;
}
void ImplementationVisitor::GetFlattenedStructsVars(
const Variable* base, std::set<const Variable*>* vars) {
const Type* type = base->type();
if (base->IsConst()) return;
if (type->IsStructType()) {
const StructType* struct_type = StructType::cast(type);
for (auto& field : struct_type->fields()) {
std::string field_var_name = base->name() + "." + field.name;
GetFlattenedStructsVars(
Variable::cast(declarations()->LookupValue(field_var_name)), vars);
}
} else {
vars->insert(base);
}
}
void ImplementationVisitor::GenerateChangedVarsFromControlSplit(AstNode* node) {
const std::set<const Variable*>& changed_vars =
global_context_.GetControlSplitChangedVariables(
node, declarations()->GetCurrentSpecializationTypeNamesVector());
std::set<const Variable*> flattened_vars;
for (auto v : changed_vars) {
GetFlattenedStructsVars(v, &flattened_vars);
}
std::vector<const Variable*> flattened_vars_sorted(flattened_vars.begin(),
flattened_vars.end());
auto compare_variables = [](const Variable* a, const Variable* b) {
return a->value() < b->value();
};
std::sort(flattened_vars_sorted.begin(), flattened_vars_sorted.end(),
compare_variables);
source_out() << "{";
PrintCommaSeparatedList(source_out(), flattened_vars_sorted,
[](const Variable* v) { return v->value(); });
source_out() << "}";
}
const Type* ImplementationVisitor::GetCommonType(const Type* left,
const Type* right) {
const Type* common_type;
if (IsAssignableFrom(left, right)) {
common_type = left;
} else if (IsAssignableFrom(right, left)) {
common_type = right;
} else {
common_type = TypeOracle::GetUnionType(left, right);
}
common_type = common_type->NonConstexprVersion();
return common_type;
}
VisitResult ImplementationVisitor::GenerateCopy(const VisitResult& to_copy) {
std::string temp = GenerateNewTempVariable(to_copy.type());
source_out() << RValueFlattenStructs(to_copy) << ";\n";
GenerateIndent();
source_out() << "USE(" << temp << ");\n";
return VisitResult(to_copy.type(), temp);
}
VisitResult ImplementationVisitor::Visit(StructExpression* decl) {
const Type* raw_type = declarations()->LookupType(decl->name);
if (!raw_type->IsStructType()) {
std::stringstream s;
s << decl->name << " is not a struct but used like one ";
ReportError(s.str());
}
const StructType* struct_type = StructType::cast(raw_type);
if (struct_type->fields().size() != decl->expressions.size()) {
std::stringstream s;
s << "initializer count mismatch for struct " << decl->name << " (expected "
<< struct_type->fields().size() << ", found " << decl->expressions.size()
<< ")";
ReportError(s.str());
}
std::vector<VisitResult> expression_results;
for (auto& field : struct_type->fields()) {
VisitResult value = Visit(decl->expressions[expression_results.size()]);
value = GenerateImplicitConvert(field.type, value);
expression_results.push_back(value);
}
std::string result_var_name = GenerateNewTempVariable(struct_type);
source_out() << "{";
PrintCommaSeparatedList(
source_out(), expression_results,
[&](const VisitResult& result) { return RValueFlattenStructs(result); });
source_out() << "};\n";
return VisitResult(struct_type, result_var_name);
}
LocationReference ImplementationVisitor::GetLocationReference(
LocationExpression* location) {
switch (location->kind) {
case AstNode::Kind::kIdentifierExpression:
return GetLocationReference(static_cast<IdentifierExpression*>(location));
case AstNode::Kind::kFieldAccessExpression:
return GetLocationReference(
static_cast<FieldAccessExpression*>(location));
case AstNode::Kind::kElementAccessExpression:
return GetLocationReference(
static_cast<ElementAccessExpression*>(location));
default:
UNREACHABLE();
}
}
LocationReference ImplementationVisitor::GetLocationReference(
FieldAccessExpression* expr) {
VisitResult result = Visit(expr->object);
if (result.type()->IsStructType()) {
if (result.declarable()) {
return LocationReference(
declarations()->LookupValue((*result.declarable())->name() + "." +
expr->field),
{}, {});
}
}
return LocationReference(nullptr, result, {});
}
std::string ImplementationVisitor::RValueFlattenStructs(VisitResult result) {
if (result.declarable()) {
const Value* value = *result.declarable();
const Type* type = value->type();
if (const StructType* struct_type = StructType::DynamicCast(type)) {
std::stringstream s;
s << struct_type->name() << "{";
PrintCommaSeparatedList(
s, struct_type->fields(), [&](const NameAndType& field) {
std::string field_declaration = value->name() + "." + field.name;
Variable* field_variable =
Variable::cast(declarations()->LookupValue(field_declaration));
return RValueFlattenStructs(
VisitResult(field_variable->type(), field_variable));
});
s << "}";
return s.str();
}
}
return result.RValue();
}
VisitResult ImplementationVisitor::GenerateFetchFromLocation(
LocationExpression* location, LocationReference reference) {
switch (location->kind) {
case AstNode::Kind::kIdentifierExpression:
return GenerateFetchFromLocation(
static_cast<IdentifierExpression*>(location), reference);
case AstNode::Kind::kFieldAccessExpression:
return GenerateFetchFromLocation(
static_cast<FieldAccessExpression*>(location), reference);
case AstNode::Kind::kElementAccessExpression:
return GenerateFetchFromLocation(
static_cast<ElementAccessExpression*>(location), reference);
default:
UNREACHABLE();
}
}
VisitResult ImplementationVisitor::GenerateFetchFromLocation(
FieldAccessExpression* expr, LocationReference reference) {
if (reference.value != nullptr) {
return GenerateFetchFromLocation(reference);
}
const Type* type = reference.base.type();
if (const StructType* struct_type = StructType::DynamicCast(type)) {
return VisitResult(struct_type->GetFieldType(expr->field),
reference.base.RValue() + "." + expr->field);
} else {
Arguments arguments;
arguments.parameters = {reference.base};
return GenerateCall(std::string(".") + expr->field, arguments);
}
}
void ImplementationVisitor::GenerateAssignToVariable(Variable* var,
VisitResult value) {
if (var->type()->IsStructType()) {
if (value.type() != var->type()) {
std::stringstream s;
s << "incompatable assignment from type " << *value.type() << " to "
<< *var->type();
ReportError(s.str());
}
const StructType* struct_type = StructType::cast(var->type());
for (auto& field : struct_type->fields()) {
std::string field_declaration = var->name() + "." + field.name;
Variable* field_variable =
Variable::cast(declarations()->LookupValue(field_declaration));
if (value.declarable() && (*value.declarable())->IsVariable()) {
Variable* source_field = Variable::cast(declarations()->LookupValue(
Variable::cast((*value.declarable()))->name() + "." + field.name));
GenerateAssignToVariable(
field_variable, VisitResult{source_field->type(), source_field});
} else {
GenerateAssignToVariable(
field_variable, VisitResult{field_variable->type(),
value.RValue() + "." + field.name});
}
}
} else {
VisitResult casted_value = GenerateImplicitConvert(var->type(), value);
GenerateIndent();
VisitResult var_value = {var->type(), var};
source_out() << var_value.LValue() << " = "
<< RValueFlattenStructs(casted_value) << ";\n";
}
var->Define();
}
void ImplementationVisitor::GenerateAssignToLocation(
LocationExpression* location, const LocationReference& reference,
VisitResult assignment_value) {
if (reference.value != nullptr) {
Value* value = reference.value;
Variable* var = Variable::cast(value);
if (var->IsConst()) {
std::stringstream s;
s << "\"" << var->name()
<< "\" is declared const (maybe implicitly) and cannot be assigned to";
ReportError(s.str());
}
GenerateAssignToVariable(var, assignment_value);
} else if (auto access = FieldAccessExpression::DynamicCast(location)) {
GenerateCall(std::string(".") + access->field + "=",
{{reference.base, assignment_value}, {}});
} else {
DCHECK_NOT_NULL(ElementAccessExpression::cast(location));
GenerateCall("[]=",
{{reference.base, reference.index, assignment_value}, {}});
}
}
void ImplementationVisitor::GenerateVariableDeclaration(const Variable* var) {
const Type* var_type = var->type();
if (var_type->IsStructType()) {
const StructType* struct_type = StructType::cast(var_type);
for (auto& field : struct_type->fields()) {
GenerateVariableDeclaration(Variable::cast(
declarations()->LookupValue(var->name() + "." + field.name)));
}
} else {
std::string value = var->value();
GenerateIndent();
if (var_type->IsConstexpr()) {
source_out() << var_type->GetGeneratedTypeName();
source_out() << " " << value << "_impl;\n";
} else if (var->IsConst()) {
source_out() << "TNode<" << var->type()->GetGeneratedTNodeTypeName();
source_out() << "> " << var->value() << "_impl;\n";
} else {
source_out() << "TVARIABLE(";
source_out() << var_type->GetGeneratedTNodeTypeName();
source_out() << ", " << value << "_impl);\n";
}
GenerateIndent();
source_out() << "auto " << value << " = &" << value << "_impl;\n";
GenerateIndent();
source_out() << "USE(" << value << ");\n";
}
}
Variable* ImplementationVisitor::GeneratePredeclaredVariableDeclaration(
const std::string& name,
const base::Optional<VisitResult>& initialization) {
Variable* variable = Variable::cast(declarations()->LookupValue(name));
GenerateVariableDeclaration(variable);
if (initialization) {
GenerateAssignToVariable(variable, *initialization);
}
return variable;
}
Variable* ImplementationVisitor::GenerateVariableDeclaration(
AstNode* node, const std::string& name, bool is_const,
const base::Optional<const Type*>& type,
const base::Optional<VisitResult>& initialization) {
Variable* variable = nullptr;
if (declarations()->IsDeclaredInCurrentScope(name)) {
variable = Variable::cast(declarations()->LookupValue(name));
} else {
variable = declarations()->DeclareVariable(
name, type ? *type : initialization->type(), is_const);
if (!is_const) {
// Because the variable is being defined during code generation, it must
// be assumed that it changes along all control split paths because it's
// no longer possible to run the control-flow anlaysis in the declaration
// pass over the variable.
global_context_.MarkVariableChanged(
node, declarations()->GetCurrentSpecializationTypeNamesVector(),
variable);
}
}
GenerateVariableDeclaration(variable);
if (initialization) {
GenerateAssignToVariable(variable, *initialization);
}
return variable;
}
void ImplementationVisitor::GenerateParameter(
const std::string& parameter_name) {
const Value* val = declarations()->LookupValue(parameter_name);
std::string var = val->value();
GenerateIndent();
source_out() << val->type()->GetGeneratedTypeName() << " " << var << " = ";
source_out() << "UncheckedCast<" << val->type()->GetGeneratedTNodeTypeName()
<< ">(Parameter(Descriptor::k" << CamelifyString(parameter_name)
<< "));\n";
GenerateIndent();
source_out() << "USE(" << var << ");\n";
}
void ImplementationVisitor::GenerateParameterList(const NameVector& list,
size_t first) {
for (auto p : list) {
if (first == 0) {
GenerateParameter(p);
} else {
first--;
}
}
}
VisitResult ImplementationVisitor::GeneratePointerCall(
Expression* callee, const Arguments& arguments, bool is_tailcall) {
TypeVector parameter_types(arguments.parameters.GetTypeVector());
VisitResult callee_result = Visit(callee);
if (!callee_result.type()->IsFunctionPointerType()) {
std::stringstream stream;
stream << "Expected a function pointer type but found "
<< *callee_result.type();
ReportError(stream.str());
}
const FunctionPointerType* type =
FunctionPointerType::cast(callee_result.type());
if (type->parameter_types().size() != parameter_types.size()) {
std::stringstream stream;
stream << "parameter count mismatch calling function pointer with Type: "
<< *type << " - expected "
<< std::to_string(type->parameter_types().size()) << ", found "
<< std::to_string(parameter_types.size());
ReportError(stream.str());
}
ParameterTypes types{type->parameter_types(), false};
Signature sig;
sig.parameter_types = types;
if (!IsCompatibleSignature(sig, parameter_types, {})) {
std::stringstream stream;
stream << "parameters do not match function pointer signature. Expected: ("
<< type->parameter_types() << ") but got: (" << parameter_types
<< ")";
ReportError(stream.str());
}
std::vector<std::string> variables;
for (size_t current = 0; current < arguments.parameters.size(); ++current) {
const Type* to_type = type->parameter_types()[current];
VisitResult result =
GenerateImplicitConvert(to_type, arguments.parameters[current]);
variables.push_back(RValueFlattenStructs(result));
}
std::string result_variable_name;
bool no_result = type->return_type()->IsVoidOrNever() || is_tailcall;
if (no_result) {
GenerateIndent();
} else {
const Type* return_type = type->return_type();
result_variable_name = GenerateNewTempVariable(return_type);
if (return_type->IsStructType()) {
source_out() << "(";
} else {
source_out() << "UncheckedCast<";
source_out() << type->return_type()->GetGeneratedTNodeTypeName();
source_out() << ">(";
}
}
Builtin* example_builtin =
declarations()->FindSomeInternalBuiltinWithType(type);
if (!example_builtin) {
std::stringstream stream;
stream << "unable to find any builtin with type \"" << *type << "\"";
ReportError(stream.str());
}
if (is_tailcall) {
source_out() << "TailCallStub(";
} else {
source_out() << "CallStub(";
}
source_out() << "Builtins::CallableFor(isolate(), Builtins::k"
<< example_builtin->name() << ").descriptor(), "
<< RValueFlattenStructs(callee_result) << ", ";
size_t total_parameters = 0;
for (size_t i = 0; i < arguments.parameters.size(); ++i) {
if (total_parameters++ != 0) {
source_out() << ", ";
}
source_out() << variables[i];
}
if (!no_result) {
source_out() << ")";
}
source_out() << ");\n";
return VisitResult(type->return_type(), result_variable_name);
}
VisitResult ImplementationVisitor::GenerateCall(
const std::string& callable_name, Arguments arguments,
const TypeVector& specialization_types, bool is_tailcall) {
Callable* callable =
LookupCall(callable_name, arguments, specialization_types);
// Operators used in a branching context can also be function calls that never
// return but have a True and False label
if (arguments.labels.size() == 0 &&
callable->signature().labels.size() == 2) {
Label* true_label = declarations()->LookupLabel(kTrueLabelName);
arguments.labels.push_back(true_label);
Label* false_label = declarations()->LookupLabel(kFalseLabelName);
arguments.labels.push_back(false_label);
}
const Type* result_type = callable->signature().return_type;
std::vector<std::string> variables;
for (size_t current = 0; current < arguments.parameters.size(); ++current) {
const Type* to_type = (current >= callable->signature().types().size())
? TypeOracle::GetObjectType()
: callable->signature().types()[current];
VisitResult result =
GenerateImplicitConvert(to_type, arguments.parameters[current]);
variables.push_back(RValueFlattenStructs(result));
}
std::string result_variable_name;
if (result_type->IsVoidOrNever() || is_tailcall) {
GenerateIndent();
} else {
result_variable_name = GenerateNewTempVariable(result_type);
if (!result_type->IsConstexpr()) {
if (result_type->IsStructType()) {
source_out() << "(";
} else {
source_out() << "UncheckedCast<";
source_out() << result_type->GetGeneratedTNodeTypeName();
source_out() << ">(";
}
}
}
if (callable->IsBuiltin()) {
if (is_tailcall) {
source_out() << "TailCallBuiltin(Builtins::k" << callable->name() << ", ";
} else {
source_out() << "CallBuiltin(Builtins::k" << callable->name() << ", ";
}
} else if (callable->IsMacro()) {
if (is_tailcall) {
std::stringstream stream;
stream << "can't tail call a macro";
ReportError(stream.str());
}
source_out() << callable->name() << "(";
} else if (callable->IsRuntimeFunction()) {
if (is_tailcall) {
source_out() << "TailCallRuntime(Runtime::k" << callable->name() << ", ";
} else {
source_out() << "CallRuntime(Runtime::k" << callable->name() << ", ";
}
} else {
UNREACHABLE();
}
if (global_context_.verbose()) {
std::cout << "generating code for call to " << callable_name << "\n";
}
size_t total_parameters = 0;
for (size_t i = 0; i < arguments.parameters.size(); ++i) {
if (total_parameters++ != 0) {
source_out() << ", ";
}
source_out() << variables[i];
}
size_t label_count = callable->signature().labels.size();
if (label_count != arguments.labels.size()) {
std::stringstream s;
s << "unexpected number of otherwise labels for " << callable->name()
<< " (expected " << std::to_string(label_count) << " found "
<< std::to_string(arguments.labels.size()) << ")";
ReportError(s.str());
}
for (size_t i = 0; i < label_count; ++i) {
if (total_parameters++ != 0) {
source_out() << ", ";
}
Label* label = arguments.labels[i];
size_t callee_label_parameters =
callable->signature().labels[i].types.size();
if (label->GetParameterCount() != callee_label_parameters) {
std::stringstream s;
s << "label " << label->name()
<< " doesn't have the right number of parameters (found "
<< std::to_string(label->GetParameterCount()) << " expected "
<< std::to_string(callee_label_parameters) << ")";
ReportError(s.str());
}
source_out() << label->generated();
size_t j = 0;
for (auto t : callable->signature().labels[i].types) {
source_out() << ", ";
Variable* variable = label->GetParameter(j);
if (!(variable->type() == t)) {
std::stringstream s;
s << "mismatch of label parameters (expected " << *t << " got "
<< *label->GetParameter(j)->type() << " for parameter "
<< std::to_string(i + 1) << ")";
ReportError(s.str());
}
j++;
source_out() << variable->value();
}
label->MarkUsed();
}
if (global_context_.verbose()) {
std::cout << "finished generating code for call to " << callable_name
<< "\n";
}
if (!result_type->IsVoidOrNever() && !is_tailcall &&
!result_type->IsConstexpr()) {
source_out() << ")";
}
source_out() << ");\n";
return VisitResult(result_type, result_variable_name);
}
void ImplementationVisitor::Visit(StandardDeclaration* decl) {
Signature signature = MakeSignature(decl->callable->signature.get());
Visit(decl->callable, signature, decl->body);
}
void ImplementationVisitor::Visit(SpecializationDeclaration* decl) {
Signature signature_with_types = MakeSignature(decl->signature.get());
Declarations::NodeScopeActivator specialization_activator(declarations(),
decl);
GenericList* generic_list = declarations()->LookupGeneric(decl->name);
for (Generic* generic : generic_list->list()) {
CallableNode* callable = generic->declaration()->callable;
Signature generic_signature_with_types =
MakeSignature(callable->signature.get());
if (signature_with_types.HasSameTypesAs(generic_signature_with_types)) {
TypeVector specialization_types = GetTypeVector(decl->generic_parameters);
SpecializeGeneric({{generic, specialization_types},
callable,
decl->signature.get(),
decl->body,
decl->pos});
return;
}
}
// Because the DeclarationVisitor already performed the same lookup
// as above to find aspecialization match and already threw if it didn't
// find one, failure to find a match here should never happen.
// TODO(danno): Remember the specialization found in the declaration visitor
// so that the lookup doesn't have to be repeated here.
UNREACHABLE();
}
VisitResult ImplementationVisitor::Visit(CallExpression* expr,
bool is_tailcall) {
Arguments arguments;
std::string name = expr->callee.name;
TypeVector specialization_types =
GetTypeVector(expr->callee.generic_arguments);
bool has_template_arguments = !specialization_types.empty();
for (Expression* arg : expr->arguments)
arguments.parameters.push_back(Visit(arg));
arguments.labels = LabelsFromIdentifiers(expr->labels);
VisitResult result;
if (!has_template_arguments &&
declarations()->Lookup(expr->callee.name)->IsValue()) {
result = GeneratePointerCall(&expr->callee, arguments, is_tailcall);
} else {
result = GenerateCall(name, arguments, specialization_types, is_tailcall);
}
if (!result.type()->IsVoidOrNever()) {
GenerateIndent();
source_out() << "USE(" << RValueFlattenStructs(result) << ");\n";
}
if (is_tailcall) {
result = {TypeOracle::GetNeverType(), ""};
}
return result;
}
bool ImplementationVisitor::GenerateLabeledStatementBlocks(
const std::vector<Statement*>& blocks,
const std::vector<Label*>& statement_labels, Label* merge_label) {
bool live = false;
auto label_iterator = statement_labels.begin();
for (Statement* block : blocks) {
GenerateIndent();
source_out() << "if (" << (*label_iterator)->generated()
<< "->is_used())\n";
ScopedIndent indent(this);
GenerateLabelBind(*label_iterator++);
if (!Visit(block)->IsNever()) {
GenerateLabelGoto(merge_label);
live = true;
}
}
return live;
}
void ImplementationVisitor::GenerateBranch(const VisitResult& condition,
Label* true_label,
Label* false_label) {
GenerateIndent();
source_out() << "Branch(" << RValueFlattenStructs(condition) << ", "
<< true_label->generated() << ", " << false_label->generated()
<< ");\n";
}
bool ImplementationVisitor::GenerateExpressionBranch(
Expression* expression, const std::vector<Label*>& statement_labels,
const std::vector<Statement*>& statement_blocks, Label* merge_label) {
// Activate a new scope to define True/False catch labels
Declarations::NodeScopeActivator scope(declarations(), expression);
VisitResult expression_result = Visit(expression);
if (expression_result.type() == TypeOracle::GetBoolType()) {
GenerateBranch(expression_result, statement_labels[0], statement_labels[1]);
} else {
if (expression_result.type() != TypeOracle::GetNeverType()) {
std::stringstream s;
s << "unexpected return type " << *expression_result.type()
<< " for branch expression";
ReportError(s.str());
}
}
return GenerateLabeledStatementBlocks(statement_blocks, statement_labels,
merge_label);
}
VisitResult ImplementationVisitor::GenerateImplicitConvert(
const Type* destination_type, VisitResult source) {
if (destination_type == source.type()) {
return source;
}
if (TypeOracle::IsImplicitlyConvertableFrom(destination_type,
source.type())) {
std::string name =
GetGeneratedCallableName(kFromConstexprMacroName, {destination_type});
return GenerateCall(name, {{source}, {}}, {}, false);
} else if (IsAssignableFrom(destination_type, source.type())) {
source.SetType(destination_type);
return source;
} else {
std::stringstream s;
s << "cannot use expression of type " << *source.type()
<< " as a value of type " << *destination_type;
ReportError(s.str());
}
}
std::string ImplementationVisitor::NewTempVariable() {
std::string name("t");
name += std::to_string(next_temp_++);
return name;
}
std::string ImplementationVisitor::GenerateNewTempVariable(const Type* type) {
std::string temp = NewTempVariable();
GenerateIndent();
source_out() << type->GetGeneratedTypeName() << " " << temp << " = ";
return temp;
}
void ImplementationVisitor::GenerateLabelDefinition(Label* label,
AstNode* node) {
std::string label_string = label->generated();
std::string label_string_impl = label_string + "_impl";
GenerateIndent();
source_out() << "Label " + label_string_impl + "(this";
if (node != nullptr) {
source_out() << ", ";
GenerateChangedVarsFromControlSplit(node);
}
source_out() << ");\n";
GenerateIndent();
source_out() << "Label* " + label_string + " = &" << label_string_impl
<< ";\n";
GenerateIndent();
source_out() << "USE(" << label_string << ");\n";
}
void ImplementationVisitor::GenerateLabelBind(Label* label) {
GenerateIndent();
source_out() << "BIND(" << label->generated() << ");\n";
}
void ImplementationVisitor::GenerateLabelGoto(Label* label) {
GenerateIndent();
source_out() << "Goto(" << label->generated() << ");\n";
}
std::vector<Label*> ImplementationVisitor::LabelsFromIdentifiers(
const std::vector<std::string>& names) {
std::vector<Label*> result;
for (auto name : names) {
result.push_back(declarations()->LookupLabel(name));
}
return result;
}
} // namespace torque
} // namespace internal
} // namespace v8