v8
V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++.
Loading...
Searching...
No Matches
Classes | Namespaces | Macros
asm-parser.cc File Reference
#include "src/asmjs/asm-parser.h"
#include <math.h>
#include <string.h>
#include <algorithm>
#include <optional>
#include "src/asmjs/asm-js.h"
#include "src/asmjs/asm-types.h"
#include "src/base/overflowing-math.h"
#include "src/flags/flags.h"
#include "src/numbers/conversions-inl.h"
#include "src/parsing/scanner.h"
#include "src/wasm/wasm-limits.h"
#include "src/wasm/wasm-opcodes.h"
Include dependency graph for asm-parser.cc:

Go to the source code of this file.

Classes

class  v8::internal::wasm::AsmJsParser::TemporaryVariableScope
 

Namespaces

namespace  v8
 
namespace  v8::internal
 
namespace  v8::internal::wasm
 

Macros

#define TRACE_ASM_PARSER(...)
 
#define FAIL_AND_RETURN(ret, msg)
 
#define FAIL(msg)
 
#define FAILn(msg)
 
#define EXPECT_TOKEN_OR_RETURN(ret, token)
 
#define EXPECT_TOKEN(token)
 
#define EXPECT_TOKENn(token)
 
#define RECURSE_OR_RETURN(ret, call)
 
#define RECURSE(call)
 
#define RECURSEn(call)
 
#define TOK(name)
 
#define V(name, _junk1, _junk2, _junk3)
 
#define V(name, const_value)
 
#define V(name, Name, op, sig)
 
#define V(array_type, wasmload, wasmstore, type)
 
#define V(array_type, wasmload, wasmstore, type)
 
#define HANDLE_CASE(op, opcode, name, result)
 
#define HANDLE_CASE(op, sop, uop, dop, fop, name)
 
#define HANDLE_CASE(op, sop, uop, dop, fop, name)
 
#define V(name, Name, op, sig)
 
#define V(name, Name, op, sig)
 

Macro Definition Documentation

◆ EXPECT_TOKEN

#define EXPECT_TOKEN ( token)
Value:
EXPECT_TOKEN_OR_RETURN(, token)
EXPECT_TOKEN_OR_RETURN
#define EXPECT_TOKEN_OR_RETURN(ret, token)
Definition asm-parser.cc:47

Definition at line 55 of file asm-parser.cc.

◆ EXPECT_TOKEN_OR_RETURN

#define EXPECT_TOKEN_OR_RETURN ( ret,
token )
Value:
do { \
if (scanner_.Token() != token) { \
FAIL_AND_RETURN(ret, "Unexpected token"); \
} \
scanner_.Next(); \
} while (false)

Definition at line 47 of file asm-parser.cc.

◆ EXPECT_TOKENn

#define EXPECT_TOKENn ( token)
Value:
EXPECT_TOKEN_OR_RETURN(nullptr, token)

Definition at line 56 of file asm-parser.cc.

◆ FAIL

#define FAIL ( msg)
Value:
FAIL_AND_RETURN(, msg)
FAIL_AND_RETURN
#define FAIL_AND_RETURN(ret, msg)
Definition asm-parser.cc:35

Definition at line 44 of file asm-parser.cc.

◆ FAIL_AND_RETURN

#define FAIL_AND_RETURN ( ret,
msg )
Value:
failed_ = true; \
failure_message_ = msg; \
failure_location_ = static_cast<int>(scanner_.Position()); \
TRACE_ASM_PARSER("[asm.js failure: %s, token: '%s', see: %s:%d]\n", msg, \
scanner_.Name(scanner_.Token()).c_str(), __FILE__, \
__LINE__); \
return ret;
failed_
bool failed_
Definition regexp-parser.cc:654

Definition at line 35 of file asm-parser.cc.

◆ FAILn

#define FAILn ( msg)
Value:
FAIL_AND_RETURN(nullptr, msg)

Definition at line 45 of file asm-parser.cc.

◆ HANDLE_CASE [1/3]

#define HANDLE_CASE ( op,
opcode,
name,
result )
Value:
case TOK(op): { \
EXPECT_TOKENn(TOK(op)); \
heap_access_shift_position_ = kNoHeapAccessShift; \
AsmType* b = nullptr; \
RECURSEn(b = AdditiveExpression()); \
if (!(a->IsA(AsmType::Intish()) && b->IsA(AsmType::Intish()))) { \
FAILn("Expected intish for operator " #name "."); \
} \
current_function_builder_->Emit(kExpr##opcode); \
a = AsmType::result(); \
continue; \
}
TOK
#define TOK(name)
Definition asm-parser.cc:71
AsmType
friend AsmType
Definition asm-types.cc:160

◆ HANDLE_CASE [2/3]

#define HANDLE_CASE ( op,
sop,
uop,
dop,
fop,
name )
Value:
case op: { \
EXPECT_TOKENn(op); \
AsmType* b = nullptr; \
RECURSEn(b = ShiftExpression()); \
if (a->IsA(AsmType::Signed()) && b->IsA(AsmType::Signed())) { \
current_function_builder_->Emit(kExpr##sop); \
} else if (a->IsA(AsmType::Unsigned()) && b->IsA(AsmType::Unsigned())) { \
current_function_builder_->Emit(kExpr##uop); \
} else if (a->IsA(AsmType::Double()) && b->IsA(AsmType::Double())) { \
current_function_builder_->Emit(kExpr##dop); \
} else if (a->IsA(AsmType::Float()) && b->IsA(AsmType::Float())) { \
current_function_builder_->Emit(kExpr##fop); \
} else { \
FAILn("Expected signed, unsigned, double, or float for operator " #name \
"."); \
} \
a = AsmType::Int(); \
continue; \
}
dop
#define dop(name,...)

◆ HANDLE_CASE [3/3]

#define HANDLE_CASE ( op,
sop,
uop,
dop,
fop,
name )
Value:
case op: { \
EXPECT_TOKENn(op); \
AsmType* b = nullptr; \
RECURSEn(b = RelationalExpression()); \
if (a->IsA(AsmType::Signed()) && b->IsA(AsmType::Signed())) { \
current_function_builder_->Emit(kExpr##sop); \
} else if (a->IsA(AsmType::Unsigned()) && b->IsA(AsmType::Unsigned())) { \
current_function_builder_->Emit(kExpr##uop); \
} else if (a->IsA(AsmType::Double()) && b->IsA(AsmType::Double())) { \
current_function_builder_->Emit(kExpr##dop); \
} else if (a->IsA(AsmType::Float()) && b->IsA(AsmType::Float())) { \
current_function_builder_->Emit(kExpr##fop); \
} else { \
FAILn("Expected signed, unsigned, double, or float for operator " #name \
"."); \
} \
a = AsmType::Int(); \
continue; \
}

◆ RECURSE

#define RECURSE ( call)
Value:
RECURSE_OR_RETURN(, call)
RECURSE_OR_RETURN
#define RECURSE_OR_RETURN(ret, call)
Definition asm-parser.cc:58

Definition at line 68 of file asm-parser.cc.

◆ RECURSE_OR_RETURN

#define RECURSE_OR_RETURN ( ret,
call )
Value:
do { \
DCHECK(!failed_); \
if (GetCurrentStackPosition() < stack_limit_) { \
FAIL_AND_RETURN(ret, "Stack overflow while parsing asm.js module."); \
} \
call; \
if (failed_) return ret; \
} while (false)
stack_limit_
const uintptr_t stack_limit_
Definition regexp-parser.cc:655

Definition at line 58 of file asm-parser.cc.

◆ RECURSEn

#define RECURSEn ( call)
Value:
RECURSE_OR_RETURN(nullptr, call)

Definition at line 69 of file asm-parser.cc.

◆ TOK

#define TOK ( name)
Value:
AsmJsScanner::kToken_##name

Definition at line 71 of file asm-parser.cc.

◆ TRACE_ASM_PARSER

#define TRACE_ASM_PARSER ( ...)

Definition at line 32 of file asm-parser.cc.

◆ V [1/7]

#define V ( array_type,
wasmload,
wasmstore,
type )
Value:
if (heap_access_type_->IsA(AsmType::array_type())) { \
current_function_builder_->EmitWithPrefix( \
kExpr##type##AsmjsLoad##wasmload); \
return heap_access_type_->LoadType(); \
}

◆ V [2/7]

#define V ( array_type,
wasmload,
wasmstore,
type )
Value:
if (heap_type->IsA(AsmType::array_type())) { \
current_function_builder_->EmitWithPrefix( \
kExpr##type##AsmjsStore##wasmstore); \
return ret; \
}

◆ V [3/7]

#define V ( name,
_junk1,
_junk2,
_junk3 )
Value:
case TOK(name): \
DeclareStdlibFunc(info, VarKind::kSpecial, AsmType::name()); \
stdlib_uses_.Add(StandardMember::k##name); \
break;

◆ V [4/7]

#define V ( name,
const_value )
Value:
case TOK(name): \
DeclareGlobal(info, false, AsmType::Double(), kWasmF64, \
WasmInitExpr(const_value)); \
stdlib_uses_.Add(StandardMember::kMath##name); \
break;

◆ V [5/7]

#define V ( name,
Name,
op,
sig )
Value:
case TOK(name): \
DeclareStdlibFunc(info, VarKind::kMath##Name, stdlib_##sig##_); \
stdlib_uses_.Add(StandardMember::kMath##Name); \
break;
_
#define _
Definition js-call-reducer.cc:54

◆ V [6/7]

#define V ( name,
Name,
op,
sig )
Value:
case VarKind::kMath##Name: \
if ((op) <= 0xff) { \
current_function_builder_->Emit(op); \
} else { \
current_function_builder_->EmitWithPrefix(op); \
} \
break;

◆ V [7/7]

#define V ( name,
Name,
op,
sig )
Value:
case VarKind::kMath##Name: \
if (param_specific_types[0]->IsA(AsmType::DoubleQ())) { \
current_function_builder_->Emit(kExprF64##Name); \
} else if (param_specific_types[0]->IsA(AsmType::FloatQ())) { \
current_function_builder_->Emit(kExprF32##Name); \
} else { \
UNREACHABLE(); \
} \
break;