AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Add function tables to asm to wasm

Browse Source 
R=titzer@chromium.org,aseemgarg@chromium.org
BUG= https://code.google.com/p/v8/issues/detail?id=4203
TEST=test-asm-validator, asm-wasm.js
LOG=N

Review URL: https://codereview.chromium.org/1609893002

Cr-Commit-Position: refs/heads/master@{#33421}
This commit is contained in:
aseemgarg 2016-01-20 15:36:42 -08:00 committed by Commit bot
parent f7263b6a3f
commit 6492686241
6 changed files with 219 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/typing-asm.cc
View File

@ -721,28 +721,31 @@ Type* AsmTyper::StorageType(Type* type) {
void AsmTyper::VisitHeapAccess(Property* expr, bool assigning,
Type* assignment_type) {
Type::ArrayType* array_type = computed_type_->AsArray();
size_t size = array_size_;
// size_t size = array_size_;
Type* type = array_type->AsArray()->Element();
if (type->IsFunction()) {
if (assigning) {
FAIL(expr, "assigning to function table is illegal");
}
BinaryOperation* bin = expr->key()->AsBinaryOperation();
if (bin == NULL || bin->op() != Token::BIT_AND) {
FAIL(expr->key(), "expected & in call");
}
RECURSE(VisitWithExpectation(bin->left(), cache_.kAsmSigned,
"array index expected to be integer"));
Literal* right = bin->right()->AsLiteral();
if (right == NULL || right->raw_value()->ContainsDot()) {
FAIL(right, "call mask must be integer");
}
RECURSE(VisitWithExpectation(bin->right(), cache_.kAsmSigned,
"call mask expected to be integer"));
if (static_cast<size_t>(right->raw_value()->AsNumber()) != size - 1) {
FAIL(right, "call mask must match function table");
}
bin->set_bounds(Bounds(cache_.kAsmSigned));
// TODO(bradnelson): Fix the parser and then un-comment this part
// BinaryOperation* bin = expr->key()->AsBinaryOperation();
// if (bin == NULL || bin->op() != Token::BIT_AND) {
// FAIL(expr->key(), "expected & in call");
// }
// RECURSE(VisitWithExpectation(bin->left(), cache_.kAsmSigned,
// "array index expected to be integer"));
// Literal* right = bin->right()->AsLiteral();
// if (right == NULL || right->raw_value()->ContainsDot()) {
// FAIL(right, "call mask must be integer");
// }
// RECURSE(VisitWithExpectation(bin->right(), cache_.kAsmSigned,
// "call mask expected to be integer"));
// if (static_cast<size_t>(right->raw_value()->AsNumber()) != size - 1) {
// FAIL(right, "call mask must match function table");
// }
// bin->set_bounds(Bounds(cache_.kAsmSigned));
RECURSE(VisitWithExpectation(expr->key(), cache_.kAsmSigned,
"must be integer"));
IntersectResult(expr, type);
} else {
Literal* literal = expr->key()->AsLiteral();

95
src/wasm/asm-wasm-builder.cc
View File

@ -47,14 +47,18 @@ class AsmWasmBuilderImpl : public AstVisitor {
cache_(TypeCache::Get()),
breakable_blocks_(zone),
block_size_(0),
init_function_index(0) {
init_function_index_(0),
next_table_index_(0),
function_tables_(HashMap::PointersMatch,
ZoneHashMap::kDefaultHashMapCapacity,
ZoneAllocationPolicy(zone)) {
InitializeAstVisitor(isolate);
}
void InitializeInitFunction() {
unsigned char init[] = "__init__";
init_function_index = builder_->AddFunction();
current_function_builder_ = builder_->FunctionAt(init_function_index);
init_function_index_ = builder_->AddFunction();
current_function_builder_ = builder_->FunctionAt(init_function_index_);
current_function_builder_->SetName(init, 8);
current_function_builder_->ReturnType(kAstStmt);
current_function_builder_->Exported(1);
@ -344,8 +348,8 @@ class AsmWasmBuilderImpl : public AstVisitor {
UNREACHABLE();
}
}
RECURSE(VisitDeclarations(scope->declarations()));
RECURSE(VisitStatements(expr->body()));
RECURSE(VisitDeclarations(scope->declarations()));
}
void VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
@ -451,7 +455,7 @@ class AsmWasmBuilderImpl : public AstVisitor {
void VisitArrayLiteral(ArrayLiteral* expr) { UNREACHABLE(); }
void LoadInitFunction() {
current_function_builder_ = builder_->FunctionAt(init_function_index);
current_function_builder_ = builder_->FunctionAt(init_function_index_);
in_function_ = true;
}
@ -460,11 +464,62 @@ class AsmWasmBuilderImpl : public AstVisitor {
current_function_builder_ = nullptr;
}
void AddFunctionTable(VariableProxy* table, ArrayLiteral* funcs) {
Type::FunctionType* func_type =
funcs->bounds().lower->AsArray()->Element()->AsFunction();
LocalType return_type = TypeFrom(func_type->Result());
FunctionSig::Builder sig(zone(), return_type == kAstStmt ? 0 : 1,
func_type->Arity());
if (return_type != kAstStmt) {
sig.AddReturn(static_cast<LocalType>(return_type));
}
for (int i = 0; i < func_type->Arity(); i++) {
sig.AddParam(TypeFrom(func_type->Parameter(i)));
}
uint16_t signature_index = builder_->AddSignature(sig.Build());
InsertFunctionTable(table->var(), next_table_index_, signature_index);
next_table_index_ += funcs->values()->length();
for (int i = 0; i < funcs->values()->length(); i++) {
VariableProxy* func = funcs->values()->at(i)->AsVariableProxy();
DCHECK(func != nullptr);
builder_->AddIndirectFunction(LookupOrInsertFunction(func->var()));
}
}
struct FunctionTableIndices : public ZoneObject {
uint32_t start_index;
uint16_t signature_index;
};
void InsertFunctionTable(Variable* v, uint32_t start_index,
uint16_t signature_index) {
FunctionTableIndices* container = new (zone()) FunctionTableIndices();
container->start_index = start_index;
container->signature_index = signature_index;
ZoneHashMap::Entry* entry = function_tables_.LookupOrInsert(
v, ComputePointerHash(v), ZoneAllocationPolicy(zone()));
entry->value = container;
}
FunctionTableIndices* LookupFunctionTable(Variable* v) {
ZoneHashMap::Entry* entry =
function_tables_.Lookup(v, ComputePointerHash(v));
DCHECK(entry != nullptr);
return reinterpret_cast<FunctionTableIndices*>(entry->value);
}
void VisitAssignment(Assignment* expr) {
bool in_init = false;
if (!in_function_) {
// TODO(bradnelson): Get rid of this.
if (TypeOf(expr->value()) == kAstStmt) {
ArrayLiteral* funcs = expr->value()->AsArrayLiteral();
if (funcs != nullptr &&
funcs->bounds().lower->AsArray()->Element()->IsFunction()) {
VariableProxy* target = expr->target()->AsVariableProxy();
DCHECK(target != nullptr);
AddFunctionTable(target, funcs);
}
return;
}
in_init = true;
@ -567,16 +622,31 @@ class AsmWasmBuilderImpl : public AstVisitor {
DCHECK(in_function_);
current_function_builder_->Emit(kExprCallFunction);
RECURSE(Visit(expr->expression()));
ZoneList<Expression*>* args = expr->arguments();
for (int i = 0; i < args->length(); ++i) {
Expression* arg = args->at(i);
RECURSE(Visit(arg));
}
break;
}
case Call::KEYED_PROPERTY_CALL: {
DCHECK(in_function_);
Property* p = expr->expression()->AsProperty();
DCHECK(p != nullptr);
VariableProxy* var = p->obj()->AsVariableProxy();
DCHECK(var != nullptr);
FunctionTableIndices* indices = LookupFunctionTable(var->var());
current_function_builder_->EmitWithU8(kExprCallIndirect,
indices->signature_index);
current_function_builder_->Emit(kExprI32Add);
byte code[] = {WASM_I32(indices->start_index)};
current_function_builder_->EmitCode(code, sizeof(code));
RECURSE(Visit(p->key()));
break;
}
default:
UNREACHABLE();
}
ZoneList<Expression*>* args = expr->arguments();
for (int i = 0; i < args->length(); ++i) {
Expression* arg = args->at(i);
RECURSE(Visit(arg));
}
}
void VisitCallNew(CallNew* expr) { UNREACHABLE(); }
@ -768,6 +838,7 @@ class AsmWasmBuilderImpl : public AstVisitor {
BINOP_CASE(Token::MUL, Mul, NON_SIGNED_BINOP, true);
BINOP_CASE(Token::DIV, Div, SIGNED_BINOP, false);
BINOP_CASE(Token::BIT_OR, Ior, NON_SIGNED_INT_BINOP, true);
BINOP_CASE(Token::BIT_AND, And, NON_SIGNED_INT_BINOP, true);
BINOP_CASE(Token::BIT_XOR, Xor, NON_SIGNED_INT_BINOP, true);
BINOP_CASE(Token::SHL, Shl, NON_SIGNED_INT_BINOP, true);
BINOP_CASE(Token::SAR, ShrS, NON_SIGNED_INT_BINOP, true);
@ -1020,7 +1091,9 @@ class AsmWasmBuilderImpl : public AstVisitor {
TypeCache const& cache_;
ZoneVector<std::pair<BreakableStatement*, bool>> breakable_blocks_;
int block_size_;
uint16_t init_function_index;
uint16_t init_function_index_;
uint32_t next_table_index_;
ZoneHashMap function_tables_;
DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();

28
src/wasm/encoder.cc
View File

@ -121,12 +121,6 @@ void WasmFunctionBuilder::EmitWithU8(WasmOpcode opcode, const byte immediate) {
}
void WasmFunctionBuilder::EmitWithLocal(WasmOpcode opcode) {
body_.push_back(static_cast<byte>(opcode));
local_indices_.push_back(static_cast<uint32_t>(body_.size()) - 1);
}
uint32_t WasmFunctionBuilder::EmitEditableImmediate(const byte immediate) {
body_.push_back(immediate);
return static_cast<uint32_t>(body_.size()) - 1;
@ -370,21 +364,21 @@ void WasmModuleBuilder::AddDataSegment(WasmDataSegmentEncoder* data) {
}
int WasmModuleBuilder::CompareFunctionSigs::operator()(FunctionSig* a,
FunctionSig* b) const {
if (a->return_count() < b->return_count()) return -1;
if (a->return_count() > b->return_count()) return 1;
if (a->parameter_count() < b->parameter_count()) return -1;
if (a->parameter_count() > b->parameter_count()) return 1;
bool WasmModuleBuilder::CompareFunctionSigs::operator()(FunctionSig* a,
FunctionSig* b) const {
if (a->return_count() < b->return_count()) return true;
if (a->return_count() > b->return_count()) return false;
if (a->parameter_count() < b->parameter_count()) return true;
if (a->parameter_count() > b->parameter_count()) return false;
for (size_t r = 0; r < a->return_count(); r++) {
if (a->GetReturn(r) < b->GetReturn(r)) return -1;
if (a->GetReturn(r) > b->GetReturn(r)) return 1;
if (a->GetReturn(r) < b->GetReturn(r)) return true;
if (a->GetReturn(r) > b->GetReturn(r)) return false;
}
for (size_t p = 0; p < a->parameter_count(); p++) {
if (a->GetParam(p) < b->GetParam(p)) return -1;
if (a->GetParam(p) > b->GetParam(p)) return 1;
if (a->GetParam(p) < b->GetParam(p)) return true;
if (a->GetParam(p) > b->GetParam(p)) return false;
}
return 0;
return false;
}

3
src/wasm/encoder.h
View File

@ -60,7 +60,6 @@ class WasmFunctionBuilder : public ZoneObject {
const uint32_t* local_indices, uint32_t indices_size);
void Emit(WasmOpcode opcode);
void EmitWithU8(WasmOpcode opcode, const byte immediate);
void EmitWithLocal(WasmOpcode opcode);
uint32_t EmitEditableImmediate(const byte immediate);
void EditImmediate(uint32_t offset, const byte immediate);
void Exported(uint8_t flag);
@ -136,7 +135,7 @@ class WasmModuleBuilder : public ZoneObject {
private:
struct CompareFunctionSigs {
int operator()(FunctionSig* a, FunctionSig* b) const;
bool operator()(FunctionSig* a, FunctionSig* b) const;
};
typedef ZoneMap<FunctionSig*, uint16_t, CompareFunctionSigs> SignatureMap;

4
test/cctest/test-asm-validator.cc
View File

@ -1522,7 +1522,9 @@ TEST(FunctionTables) {
CHECK_EXPR(Property, FUNC_I2I_TYPE) {
CHECK_VAR(table1, FUNC_I2I_ARRAY_TYPE);
CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
CHECK_VAR(x, Bounds(cache.kAsmSigned));
// TODO(bradnelson): revert this
// CHECK_VAR(x, Bounds(cache.kAsmSigned));
CHECK_VAR(x, Bounds(cache.kAsmInt));
CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
}
}

100
test/mjsunit/wasm/asm-wasm.js
View File

@ -858,3 +858,103 @@ var module = _WASMEXP_.instantiateModuleFromAsm(
TestExportNameDifferentFromFunctionName.toString());
module.__init__();
assertEquals(55, module.alt_caller());
function TestFunctionTableSingleFunction() {
"use asm";
function dummy() {
return 71;
}
function caller() {
return function_table[0&0]() | 0;
}
var function_table = [dummy]
return {caller:caller};
}
assertEquals(71,
_WASMEXP_.asmCompileRun(TestFunctionTableSingleFunction.toString()));
function TestFunctionTableMultipleFunctions() {
"use asm";
function inc1(x) {
x = x|0;
return (x+1)|0;
}
function inc2(x) {
x = x|0;
return (x+2)|0;
}
function caller() {
if (function_table[0&1](50) == 51) {
if (function_table[1&1](60) == 62) {
return 73;
}
}
return 0;
}
var function_table = [inc1, inc2]
return {caller:caller};
}
assertEquals(73,
_WASMEXP_.asmCompileRun(TestFunctionTableMultipleFunctions.toString()));
function TestFunctionTable() {
"use asm";
function add(a, b) {
a = a|0;
b = b|0;
return (a+b)|0;
}
function sub(a, b) {
a = a|0;
b = b|0;
return (a-b)|0;
}
function inc(a) {
a = a|0;
return (a+1)|0;
}
function caller(table_id, fun_id, arg1, arg2) {
table_id = table_id|0;
fun_id = fun_id|0;
arg1 = arg1|0;
arg2 = arg2|0;
if (table_id == 0) {
return funBin[fun_id&3](arg1, arg2)|0;
} else if (table_id == 1) {
return fun[fun_id&0](arg1)|0;
}
return 0;
}
var funBin = [add, sub, sub, add];
var fun = [inc];
return {caller:caller};
}
var module = _WASMEXP_.instantiateModuleFromAsm(TestFunctionTable.toString());
module.__init__();
assertEquals(55, module.caller(0, 0, 33, 22));
assertEquals(11, module.caller(0, 1, 33, 22));
assertEquals(9, module.caller(0, 2, 54, 45));
assertEquals(99, module.caller(0, 3, 54, 45));
assertEquals(23, module.caller(0, 4, 12, 11));
assertEquals(31, module.caller(1, 0, 30, 11));