// 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 "src/torque/declarations.h"
|
#include "src/torque/declarable.h"
|
#include "src/torque/type-oracle.h"
|
|
namespace v8 {
|
namespace internal {
|
namespace torque {
|
|
Scope* Declarations::GetModuleScope(const Module* module) {
|
auto i = module_scopes_.find(module);
|
if (i != module_scopes_.end()) return i->second;
|
Scope* result = chain_.NewScope();
|
module_scopes_[module] = result;
|
return result;
|
}
|
|
Scope* Declarations::GetNodeScope(const AstNode* node, bool reset_scope) {
|
std::pair<const AstNode*, TypeVector> key(
|
node, current_generic_specialization_ == nullptr
|
? TypeVector()
|
: current_generic_specialization_->second);
|
if (!reset_scope) {
|
auto i = scopes_.find(key);
|
if (i != scopes_.end()) return i->second;
|
}
|
Scope* result = chain_.NewScope();
|
scopes_[key] = result;
|
return result;
|
}
|
|
Scope* Declarations::GetGenericScope(Generic* generic,
|
const TypeVector& types) {
|
std::pair<const AstNode*, TypeVector> key(generic->declaration()->callable,
|
types);
|
auto i = scopes_.find(key);
|
if (i != scopes_.end()) return i->second;
|
Scope* result = chain_.NewScope();
|
scopes_[key] = result;
|
return result;
|
}
|
|
bool Declarations::IsDeclaredInCurrentScope(const std::string& name) {
|
return chain_.ShallowLookup(name) != nullptr;
|
}
|
|
void Declarations::CheckAlreadyDeclared(const std::string& name,
|
const char* new_type) {
|
if (IsDeclaredInCurrentScope(name)) {
|
std::stringstream s;
|
s << "cannot redeclare " << name << " (type " << new_type << ")";
|
ReportError(s.str());
|
}
|
}
|
|
const Type* Declarations::LookupType(const std::string& name) {
|
Declarable* raw = Lookup(name);
|
if (raw->IsTypeAlias()) {
|
return TypeAlias::cast(raw)->type();
|
}
|
std::stringstream s;
|
s << "declaration \"" << name << "\" is not a Type";
|
ReportError(s.str());
|
return nullptr;
|
}
|
|
const Type* Declarations::LookupGlobalType(const std::string& name) {
|
Declarable* raw = LookupGlobalScope(name);
|
if (!raw->IsTypeAlias()) {
|
std::stringstream s;
|
s << "declaration \"" << name << "\" is not a Type";
|
ReportError(s.str());
|
}
|
return TypeAlias::cast(raw)->type();
|
}
|
|
const Type* Declarations::GetType(TypeExpression* type_expression) {
|
if (auto* basic = BasicTypeExpression::DynamicCast(type_expression)) {
|
std::string name =
|
(basic->is_constexpr ? CONSTEXPR_TYPE_PREFIX : "") + basic->name;
|
return LookupType(name);
|
} else if (auto* union_type = UnionTypeExpression::cast(type_expression)) {
|
return TypeOracle::GetUnionType(GetType(union_type->a),
|
GetType(union_type->b));
|
} else {
|
auto* function_type_exp = FunctionTypeExpression::cast(type_expression);
|
TypeVector argument_types;
|
for (TypeExpression* type_exp : function_type_exp->parameters) {
|
argument_types.push_back(GetType(type_exp));
|
}
|
return TypeOracle::GetFunctionPointerType(
|
argument_types, GetType(function_type_exp->return_type));
|
}
|
}
|
|
Builtin* Declarations::FindSomeInternalBuiltinWithType(
|
const FunctionPointerType* type) {
|
for (auto& declarable : declarables_) {
|
if (Builtin* builtin = Builtin::DynamicCast(declarable.get())) {
|
if (!builtin->IsExternal() && builtin->kind() == Builtin::kStub &&
|
builtin->signature().return_type == type->return_type() &&
|
builtin->signature().parameter_types.types ==
|
type->parameter_types()) {
|
return builtin;
|
}
|
}
|
}
|
return nullptr;
|
}
|
|
Value* Declarations::LookupValue(const std::string& name) {
|
Declarable* d = Lookup(name);
|
if (!d->IsValue()) {
|
std::stringstream s;
|
s << "declaration \"" << name << "\" is not a Value";
|
ReportError(s.str());
|
}
|
return Value::cast(d);
|
}
|
|
Label* Declarations::LookupLabel(const std::string& name) {
|
Declarable* d = Lookup(name);
|
if (!d->IsLabel()) {
|
std::stringstream s;
|
s << "declaration \"" << name << "\" is not a Label";
|
ReportError(s.str());
|
}
|
return Label::cast(d);
|
}
|
|
Macro* Declarations::TryLookupMacro(const std::string& name,
|
const TypeVector& types) {
|
Declarable* declarable = TryLookup(name);
|
if (declarable != nullptr) {
|
if (declarable->IsMacroList()) {
|
for (auto& m : MacroList::cast(declarable)->list()) {
|
if (m->signature().parameter_types.types == types &&
|
!m->signature().parameter_types.var_args) {
|
return m;
|
}
|
}
|
}
|
}
|
return nullptr;
|
}
|
|
Macro* Declarations::LookupMacro(const std::string& name,
|
const TypeVector& types) {
|
Macro* result = TryLookupMacro(name, types);
|
if (result != nullptr) return result;
|
std::stringstream stream;
|
stream << "macro " << name << " with parameter types " << types
|
<< " is not defined";
|
ReportError(stream.str());
|
return nullptr;
|
}
|
|
Builtin* Declarations::LookupBuiltin(const std::string& name) {
|
Declarable* declarable = Lookup(name);
|
if (declarable != nullptr) {
|
if (declarable->IsBuiltin()) {
|
return Builtin::cast(declarable);
|
}
|
ReportError(name + " is not a builtin");
|
}
|
ReportError(std::string("builtin ") + name + " is not defined");
|
return nullptr;
|
}
|
|
GenericList* Declarations::LookupGeneric(const std::string& name) {
|
Declarable* declarable_list = Lookup(name);
|
if (declarable_list != nullptr) {
|
if (declarable_list->IsGenericList()) {
|
return GenericList::cast(declarable_list);
|
}
|
ReportError(name + " is not a generic");
|
}
|
ReportError(std::string("generic ") + name + " is not defined");
|
return nullptr;
|
}
|
|
ModuleConstant* Declarations::LookupModuleConstant(const std::string& name) {
|
Declarable* declarable = Lookup(name);
|
if (declarable != nullptr) {
|
if (declarable->IsModuleConstant()) {
|
return ModuleConstant::cast(declarable);
|
}
|
ReportError(name + " is not a constant");
|
}
|
ReportError(std::string("constant \"") + name + "\" is not defined");
|
return nullptr;
|
}
|
|
const AbstractType* Declarations::DeclareAbstractType(
|
const std::string& name, const std::string& generated,
|
base::Optional<const AbstractType*> non_constexpr_version,
|
const base::Optional<std::string>& parent) {
|
CheckAlreadyDeclared(name, "type");
|
const Type* parent_type = nullptr;
|
if (parent) {
|
Declarable* maybe_parent_type = Lookup(*parent);
|
if (maybe_parent_type == nullptr) {
|
std::stringstream s;
|
s << "cannot find parent type \"" << *parent << "\"";
|
ReportError(s.str());
|
}
|
if (!maybe_parent_type->IsTypeAlias()) {
|
std::stringstream s;
|
s << "parent \"" << *parent << "\" of type \"" << name << "\""
|
<< " is not a type";
|
ReportError(s.str());
|
}
|
parent_type = TypeAlias::cast(maybe_parent_type)->type();
|
}
|
const AbstractType* type = TypeOracle::GetAbstractType(
|
parent_type, name, generated, non_constexpr_version);
|
DeclareType(name, type);
|
return type;
|
}
|
|
void Declarations::DeclareType(const std::string& name, const Type* type) {
|
CheckAlreadyDeclared(name, "type");
|
TypeAlias* result = new TypeAlias(type);
|
Declare(name, std::unique_ptr<TypeAlias>(result));
|
}
|
|
void Declarations::DeclareStruct(Module* module, const std::string& name,
|
const std::vector<NameAndType>& fields) {
|
const StructType* new_type = TypeOracle::GetStructType(module, name, fields);
|
DeclareType(name, new_type);
|
}
|
|
Label* Declarations::DeclareLabel(const std::string& name) {
|
CheckAlreadyDeclared(name, "label");
|
Label* result = new Label(name);
|
Declare(name, std::unique_ptr<Declarable>(result));
|
return result;
|
}
|
|
MacroList* Declarations::GetMacroListForName(const std::string& name,
|
const Signature& signature) {
|
auto previous = chain_.Lookup(name);
|
MacroList* macro_list = nullptr;
|
if (previous == nullptr) {
|
macro_list = new MacroList();
|
Declare(name, std::unique_ptr<Declarable>(macro_list));
|
} else if (!previous->IsMacroList()) {
|
std::stringstream s;
|
s << "cannot redeclare non-macro " << name << " as a macro";
|
ReportError(s.str());
|
} else {
|
macro_list = MacroList::cast(previous);
|
}
|
for (auto& macro : macro_list->list()) {
|
if (signature.parameter_types.types ==
|
macro->signature().parameter_types.types &&
|
signature.parameter_types.var_args ==
|
macro->signature().parameter_types.var_args) {
|
std::stringstream s;
|
s << "cannot redeclare " << name
|
<< " as a macro with identical parameter list "
|
<< signature.parameter_types;
|
ReportError(s.str());
|
}
|
}
|
return macro_list;
|
}
|
|
Macro* Declarations::DeclareMacro(const std::string& name,
|
const Signature& signature,
|
base::Optional<std::string> op) {
|
Macro* macro = RegisterDeclarable(
|
std::unique_ptr<Macro>(new Macro(name, signature, GetCurrentGeneric())));
|
GetMacroListForName(name, signature)->AddMacro(macro);
|
if (op) GetMacroListForName(*op, signature)->AddMacro(macro);
|
return macro;
|
}
|
|
Builtin* Declarations::DeclareBuiltin(const std::string& name,
|
Builtin::Kind kind, bool external,
|
const Signature& signature) {
|
CheckAlreadyDeclared(name, "builtin");
|
Builtin* result =
|
new Builtin(name, kind, external, signature, GetCurrentGeneric());
|
Declare(name, std::unique_ptr<Declarable>(result));
|
return result;
|
}
|
|
RuntimeFunction* Declarations::DeclareRuntimeFunction(
|
const std::string& name, const Signature& signature) {
|
CheckAlreadyDeclared(name, "runtime function");
|
RuntimeFunction* result =
|
new RuntimeFunction(name, signature, GetCurrentGeneric());
|
Declare(name, std::unique_ptr<Declarable>(result));
|
return result;
|
}
|
|
Variable* Declarations::DeclareVariable(const std::string& var,
|
const Type* type, bool is_const) {
|
std::string name(var + "_" +
|
std::to_string(GetNextUniqueDeclarationNumber()));
|
std::replace(name.begin(), name.end(), '.', '_');
|
CheckAlreadyDeclared(var, "variable");
|
Variable* result = new Variable(var, name, type, is_const);
|
Declare(var, std::unique_ptr<Declarable>(result));
|
return result;
|
}
|
|
Parameter* Declarations::DeclareParameter(const std::string& name,
|
const std::string& var_name,
|
const Type* type) {
|
CheckAlreadyDeclared(name, "parameter");
|
Parameter* result = new Parameter(name, type, var_name);
|
Declare(name, std::unique_ptr<Declarable>(result));
|
return result;
|
}
|
|
Label* Declarations::DeclarePrivateLabel(const std::string& raw_name) {
|
std::string name =
|
raw_name + "_" + std::to_string(GetNextUniqueDeclarationNumber());
|
CheckAlreadyDeclared(name, "label");
|
Label* result = new Label(name);
|
Declare(name, std::unique_ptr<Declarable>(result));
|
return result;
|
}
|
|
void Declarations::DeclareExternConstant(const std::string& name,
|
const Type* type,
|
const std::string& value) {
|
CheckAlreadyDeclared(name, "constant, parameter or arguments");
|
ExternConstant* result = new ExternConstant(name, type, value);
|
Declare(name, std::unique_ptr<Declarable>(result));
|
}
|
|
ModuleConstant* Declarations::DeclareModuleConstant(const std::string& name,
|
const Type* type) {
|
CheckAlreadyDeclared(name, "module constant");
|
ModuleConstant* result = new ModuleConstant(name, type);
|
Declare(name, std::unique_ptr<Declarable>(result));
|
return result;
|
}
|
|
Generic* Declarations::DeclareGeneric(const std::string& name, Module* module,
|
GenericDeclaration* generic) {
|
auto previous = chain_.Lookup(name);
|
GenericList* generic_list = nullptr;
|
if (previous == nullptr) {
|
generic_list = new GenericList();
|
Declare(name, std::unique_ptr<Declarable>(generic_list));
|
} else if (!previous->IsGenericList()) {
|
std::stringstream s;
|
s << "cannot redeclare non-generic " << name << " as a generic";
|
ReportError(s.str());
|
} else {
|
generic_list = GenericList::cast(previous);
|
}
|
Generic* result = RegisterDeclarable(
|
std::unique_ptr<Generic>(new Generic(name, module, generic)));
|
generic_list->AddGeneric(result);
|
generic_declaration_scopes_[result] = GetScopeChainSnapshot();
|
return result;
|
}
|
|
TypeVector Declarations::GetCurrentSpecializationTypeNamesVector() {
|
TypeVector result;
|
if (current_generic_specialization_ != nullptr) {
|
result = current_generic_specialization_->second;
|
}
|
return result;
|
}
|
|
base::Optional<Generic*> Declarations::GetCurrentGeneric() {
|
if (current_generic_specialization_ != nullptr) {
|
return current_generic_specialization_->first;
|
}
|
return base::nullopt;
|
}
|
|
std::string GetGeneratedCallableName(const std::string& name,
|
const TypeVector& specialized_types) {
|
std::string result = name;
|
for (auto type : specialized_types) {
|
std::string type_string = type->MangledName();
|
result += std::to_string(type_string.size()) + type_string;
|
}
|
return result;
|
}
|
|
} // namespace torque
|
} // namespace internal
|
} // namespace v8
|
