1 // Copyright 2015 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_COMPILER_WASM_COMPILER_H_ 6 #define V8_COMPILER_WASM_COMPILER_H_ 7 8 #include <memory> 9 #include <utility> 10 11 // Clients of this interface shouldn't depend on lots of compiler internals. 12 // Do not include anything from src/compiler here! 13 #include "src/runtime/runtime.h" 14 #include "src/wasm/function-body-decoder.h" 15 #include "src/wasm/function-compiler.h" 16 #include "src/wasm/wasm-module.h" 17 #include "src/wasm/wasm-opcodes.h" 18 #include "src/wasm/wasm-result.h" 19 #include "src/zone/zone.h" 20 21 namespace v8 { 22 namespace internal { 23 struct AssemblerOptions; 24 class OptimizedCompilationJob; 25 26 namespace compiler { 27 // Forward declarations for some compiler data structures. 28 class CallDescriptor; 29 class Graph; 30 class MachineGraph; 31 class Node; 32 class NodeOriginTable; 33 class Operator; 34 class SourcePositionTable; 35 class WasmDecorator; 36 class WasmGraphAssembler; 37 enum class TrapId : uint32_t; 38 struct Int64LoweringSpecialCase; 39 } // namespace compiler 40 41 namespace wasm { 42 struct DecodeStruct; 43 // Expose {Node} and {Graph} opaquely as {wasm::TFNode} and {wasm::TFGraph}. 44 using TFNode = compiler::Node; 45 using TFGraph = compiler::MachineGraph; 46 class WasmCode; 47 class WasmFeatures; 48 enum class LoadTransformationKind : uint8_t; 49 } // namespace wasm 50 51 namespace compiler { 52 53 wasm::WasmCompilationResult ExecuteTurbofanWasmCompilation( 54 wasm::WasmEngine*, wasm::CompilationEnv*, const wasm::FunctionBody&, 55 int func_index, Counters*, wasm::WasmFeatures* detected); 56 57 // Calls to Wasm imports are handled in several different ways, depending on the 58 // type of the target function/callable and whether the signature matches the 59 // argument arity. 60 enum class WasmImportCallKind : uint8_t { 61 kLinkError, // static Wasm->Wasm type error 62 kRuntimeTypeError, // runtime Wasm->JS type error 63 kWasmToCapi, // fast Wasm->C-API call 64 kWasmToWasm, // fast Wasm->Wasm call 65 kJSFunctionArityMatch, // fast Wasm->JS call 66 kJSFunctionArityMismatch, // Wasm->JS, needs adapter frame 67 // Math functions imported from JavaScript that are intrinsified 68 kFirstMathIntrinsic, 69 kF64Acos = kFirstMathIntrinsic, 70 kF64Asin, 71 kF64Atan, 72 kF64Cos, 73 kF64Sin, 74 kF64Tan, 75 kF64Exp, 76 kF64Log, 77 kF64Atan2, 78 kF64Pow, 79 kF64Ceil, 80 kF64Floor, 81 kF64Sqrt, 82 kF64Min, 83 kF64Max, 84 kF64Abs, 85 kF32Min, 86 kF32Max, 87 kF32Abs, 88 kF32Ceil, 89 kF32Floor, 90 kF32Sqrt, 91 kF32ConvertF64, 92 kLastMathIntrinsic = kF32ConvertF64, 93 // For everything else, there's the call builtin. 94 kUseCallBuiltin 95 }; 96 97 constexpr WasmImportCallKind kDefaultImportCallKind = 98 WasmImportCallKind::kJSFunctionArityMatch; 99 100 // Resolves which import call wrapper is required for the given JS callable. 101 // Returns the kind of wrapper need and the ultimate target callable. Note that 102 // some callables (e.g. a {WasmExportedFunction} or {WasmJSFunction}) just wrap 103 // another target, which is why the ultimate target is returned as well. 104 V8_EXPORT_PRIVATE std::pair<WasmImportCallKind, Handle<JSReceiver>> 105 ResolveWasmImportCall(Handle<JSReceiver> callable, const wasm::FunctionSig* sig, 106 const wasm::WasmModule* module, 107 const wasm::WasmFeatures& enabled_features); 108 109 // Compiles an import call wrapper, which allows Wasm to call imports. 110 V8_EXPORT_PRIVATE wasm::WasmCompilationResult CompileWasmImportCallWrapper( 111 wasm::WasmEngine*, wasm::CompilationEnv* env, WasmImportCallKind, 112 const wasm::FunctionSig*, bool source_positions, int expected_arity); 113 114 // Compiles a host call wrapper, which allows Wasm to call host functions. 115 wasm::WasmCode* CompileWasmCapiCallWrapper(wasm::WasmEngine*, 116 wasm::NativeModule*, 117 const wasm::FunctionSig*, 118 Address address); 119 120 // Returns an OptimizedCompilationJob object for a JS to Wasm wrapper. 121 std::unique_ptr<OptimizedCompilationJob> NewJSToWasmCompilationJob( 122 Isolate* isolate, wasm::WasmEngine* wasm_engine, 123 const wasm::FunctionSig* sig, const wasm::WasmModule* module, 124 bool is_import, const wasm::WasmFeatures& enabled_features); 125 126 MaybeHandle<Code> CompileWasmToJSWrapper(Isolate* isolate, 127 const wasm::FunctionSig* sig, 128 WasmImportCallKind kind, 129 int expected_arity); 130 131 // Compiles a stub with JS linkage that serves as an adapter for function 132 // objects constructed via {WebAssembly.Function}. It performs a round-trip 133 // simulating a JS-to-Wasm-to-JS coercion of parameter and return values. 134 MaybeHandle<Code> CompileJSToJSWrapper(Isolate*, const wasm::FunctionSig*, 135 const wasm::WasmModule* module); 136 137 enum CWasmEntryParameters { 138 kCodeEntry, 139 kObjectRef, 140 kArgumentsBuffer, 141 kCEntryFp, 142 // marker: 143 kNumParameters 144 }; 145 146 // Compiles a stub with C++ linkage, to be called from Execution::CallWasm, 147 // which knows how to feed it its parameters. 148 V8_EXPORT_PRIVATE Handle<Code> CompileCWasmEntry( 149 Isolate*, const wasm::FunctionSig*, const wasm::WasmModule* module); 150 151 // Values from the instance object are cached between Wasm-level function calls. 152 // This struct allows the SSA environment handling this cache to be defined 153 // and manipulated in wasm-compiler.{h,cc} instead of inside the Wasm decoder. 154 // (Note that currently, the globals base is immutable, so not cached here.) 155 struct WasmInstanceCacheNodes { 156 Node* mem_start; 157 Node* mem_size; 158 Node* mem_mask; 159 }; 160 161 // Abstracts details of building TurboFan graph nodes for wasm to separate 162 // the wasm decoder from the internal details of TurboFan. 163 class WasmGraphBuilder { 164 public: 165 enum EnforceBoundsCheck : bool { // -- 166 kNeedsBoundsCheck = true, 167 kCanOmitBoundsCheck = false 168 }; 169 enum UseRetpoline : bool { // -- 170 kRetpoline = true, 171 kNoRetpoline = false 172 }; 173 enum CheckForNull : bool { // -- 174 kWithNullCheck = true, 175 kWithoutNullCheck = false 176 }; 177 enum CheckForI31 : bool { // -- 178 kWithI31Check = true, 179 kNoI31Check = false 180 }; 181 enum RttIsI31 : bool { // -- 182 kRttIsI31 = true, 183 kRttIsNotI31 = false 184 }; 185 186 V8_EXPORT_PRIVATE WasmGraphBuilder( 187 wasm::CompilationEnv* env, Zone* zone, MachineGraph* mcgraph, 188 const wasm::FunctionSig* sig, 189 compiler::SourcePositionTable* spt = nullptr); 190 191 V8_EXPORT_PRIVATE ~WasmGraphBuilder(); 192 193 //----------------------------------------------------------------------- 194 // Operations independent of {control} or {effect}. 195 //----------------------------------------------------------------------- 196 Node* Error(); 197 Node* Start(unsigned params); 198 Node* Param(unsigned index); 199 Node* Loop(Node* entry); 200 Node* TerminateLoop(Node* effect, Node* control); 201 Node* TerminateThrow(Node* effect, Node* control); 202 Node* Merge(unsigned count, Node** controls); 203 Node* Phi(wasm::ValueType type, unsigned count, Node** vals_and_control); 204 Node* CreateOrMergeIntoPhi(MachineRepresentation rep, Node* merge, 205 Node* tnode, Node* fnode); 206 Node* CreateOrMergeIntoEffectPhi(Node* merge, Node* tnode, Node* fnode); 207 Node* EffectPhi(unsigned count, Node** effects_and_control); 208 Node* RefNull(); 209 Node* RefFunc(uint32_t function_index); 210 Node* RefAsNonNull(Node* arg, wasm::WasmCodePosition position); 211 Node* Int32Constant(int32_t value); 212 Node* Int64Constant(int64_t value); 213 Node* Float32Constant(float value); 214 Node* Float64Constant(double value); 215 Node* Simd128Constant(const uint8_t value[16]); 216 Node* Binop(wasm::WasmOpcode opcode, Node* left, Node* right, 217 wasm::WasmCodePosition position = wasm::kNoCodePosition); 218 Node* Unop(wasm::WasmOpcode opcode, Node* input, 219 wasm::WasmCodePosition position = wasm::kNoCodePosition); 220 Node* MemoryGrow(Node* input); 221 Node* Throw(uint32_t exception_index, const wasm::WasmException* exception, 222 const Vector<Node*> values, wasm::WasmCodePosition position); 223 Node* Rethrow(Node* except_obj); 224 Node* ExceptionTagEqual(Node* caught_tag, Node* expected_tag); 225 Node* LoadExceptionTagFromTable(uint32_t exception_index); 226 Node* GetExceptionTag(Node* except_obj, wasm::WasmCodePosition); 227 Node* GetExceptionValues(Node* except_obj, 228 const wasm::WasmException* exception, 229 Vector<Node*> values_out); 230 bool IsPhiWithMerge(Node* phi, Node* merge); 231 bool ThrowsException(Node* node, Node** if_success, Node** if_exception); 232 void AppendToMerge(Node* merge, Node* from); 233 void AppendToPhi(Node* phi, Node* from); 234 235 void StackCheck(wasm::WasmCodePosition); 236 237 void PatchInStackCheckIfNeeded(); 238 239 //----------------------------------------------------------------------- 240 // Operations that read and/or write {control} and {effect}. 241 //----------------------------------------------------------------------- 242 Node* BranchNoHint(Node* cond, Node** true_node, Node** false_node); 243 Node* BranchExpectTrue(Node* cond, Node** true_node, Node** false_node); 244 Node* BranchExpectFalse(Node* cond, Node** true_node, Node** false_node); 245 246 Node* TrapIfTrue(wasm::TrapReason reason, Node* cond, 247 wasm::WasmCodePosition position); 248 Node* TrapIfFalse(wasm::TrapReason reason, Node* cond, 249 wasm::WasmCodePosition position); 250 Node* TrapIfEq32(wasm::TrapReason reason, Node* node, int32_t val, 251 wasm::WasmCodePosition position); 252 Node* ZeroCheck32(wasm::TrapReason reason, Node* node, 253 wasm::WasmCodePosition position); 254 Node* TrapIfEq64(wasm::TrapReason reason, Node* node, int64_t val, 255 wasm::WasmCodePosition position); 256 Node* ZeroCheck64(wasm::TrapReason reason, Node* node, 257 wasm::WasmCodePosition position); 258 259 Node* Switch(unsigned count, Node* key); 260 Node* IfValue(int32_t value, Node* sw); 261 Node* IfDefault(Node* sw); 262 Node* Return(Vector<Node*> nodes); 263 template <typename... Nodes> Return(Node * fst,Nodes * ...more)264 Node* Return(Node* fst, Nodes*... more) { 265 Node* arr[] = {fst, more...}; 266 return Return(ArrayVector(arr)); 267 } 268 269 Node* TraceFunctionEntry(wasm::WasmCodePosition position); 270 Node* TraceFunctionExit(Vector<Node*> vals, wasm::WasmCodePosition position); 271 272 Node* Trap(wasm::TrapReason reason, wasm::WasmCodePosition position); 273 274 Node* CallDirect(uint32_t index, Vector<Node*> args, Vector<Node*> rets, 275 wasm::WasmCodePosition position); 276 Node* CallIndirect(uint32_t table_index, uint32_t sig_index, 277 Vector<Node*> args, Vector<Node*> rets, 278 wasm::WasmCodePosition position); 279 Node* CallRef(uint32_t sig_index, Vector<Node*> args, Vector<Node*> rets, 280 CheckForNull null_check, wasm::WasmCodePosition position); 281 282 Node* ReturnCall(uint32_t index, Vector<Node*> args, 283 wasm::WasmCodePosition position); 284 Node* ReturnCallIndirect(uint32_t table_index, uint32_t sig_index, 285 Vector<Node*> args, wasm::WasmCodePosition position); 286 Node* ReturnCallRef(uint32_t sig_index, Vector<Node*> args, 287 CheckForNull null_check, wasm::WasmCodePosition position); 288 289 // Return value is not expected to be used, 290 // but we need it for compatibility with graph-builder-interface. 291 Node* BrOnNull(Node* ref_object, Node** non_null_node, Node** null_node); 292 293 Node* Invert(Node* node); 294 295 Node* GlobalGet(uint32_t index); 296 Node* GlobalSet(uint32_t index, Node* val); 297 Node* TableGet(uint32_t table_index, Node* index, 298 wasm::WasmCodePosition position); 299 Node* TableSet(uint32_t table_index, Node* index, Node* val, 300 wasm::WasmCodePosition position); 301 //----------------------------------------------------------------------- 302 // Operations that concern the linear memory. 303 //----------------------------------------------------------------------- 304 Node* CurrentMemoryPages(); 305 Node* TraceMemoryOperation(bool is_store, MachineRepresentation, Node* index, 306 uintptr_t offset, wasm::WasmCodePosition); 307 Node* LoadMem(wasm::ValueType type, MachineType memtype, Node* index, 308 uint64_t offset, uint32_t alignment, 309 wasm::WasmCodePosition position); 310 #if defined(V8_TARGET_BIG_ENDIAN) || defined(V8_TARGET_ARCH_S390_LE_SIM) 311 Node* LoadTransformBigEndian(wasm::ValueType type, MachineType memtype, 312 wasm::LoadTransformationKind transform, 313 Node* index, uint64_t offset, uint32_t alignment, 314 wasm::WasmCodePosition position); 315 #endif 316 Node* LoadTransform(wasm::ValueType type, MachineType memtype, 317 wasm::LoadTransformationKind transform, Node* index, 318 uint64_t offset, uint32_t alignment, 319 wasm::WasmCodePosition position); 320 Node* LoadLane(MachineType memtype, Node* value, Node* index, uint32_t offset, 321 uint8_t laneidx, wasm::WasmCodePosition position); 322 Node* StoreMem(MachineRepresentation mem_rep, Node* index, uint64_t offset, 323 uint32_t alignment, Node* val, wasm::WasmCodePosition position, 324 wasm::ValueType type); 325 Node* StoreLane(MachineRepresentation mem_rep, Node* index, uint32_t offset, 326 uint32_t alignment, Node* val, uint8_t laneidx, 327 wasm::WasmCodePosition position, wasm::ValueType type); 328 static void PrintDebugName(Node* node); 329 set_instance_node(Node * instance_node)330 void set_instance_node(Node* instance_node) { 331 this->instance_node_ = instance_node; 332 } 333 334 Node* effect(); 335 Node* control(); 336 Node* SetEffect(Node* node); 337 Node* SetControl(Node* node); 338 void SetEffectControl(Node* effect, Node* control); SetEffectControl(Node * effect_and_control)339 Node* SetEffectControl(Node* effect_and_control) { 340 SetEffectControl(effect_and_control, effect_and_control); 341 return effect_and_control; 342 } 343 344 Node* GetImportedMutableGlobals(); 345 346 void GetGlobalBaseAndOffset(MachineType mem_type, const wasm::WasmGlobal&, 347 Node** base_node, Node** offset_node); 348 349 void GetBaseAndOffsetForImportedMutableExternRefGlobal( 350 const wasm::WasmGlobal& global, Node** base, Node** offset); 351 352 // Utilities to manipulate sets of instance cache nodes. 353 void InitInstanceCache(WasmInstanceCacheNodes* instance_cache); 354 void PrepareInstanceCacheForLoop(WasmInstanceCacheNodes* instance_cache, 355 Node* control); 356 void NewInstanceCacheMerge(WasmInstanceCacheNodes* to, 357 WasmInstanceCacheNodes* from, Node* merge); 358 void MergeInstanceCacheInto(WasmInstanceCacheNodes* to, 359 WasmInstanceCacheNodes* from, Node* merge); 360 set_instance_cache(WasmInstanceCacheNodes * instance_cache)361 void set_instance_cache(WasmInstanceCacheNodes* instance_cache) { 362 this->instance_cache_ = instance_cache; 363 } 364 GetFunctionSignature()365 const wasm::FunctionSig* GetFunctionSignature() { return sig_; } 366 367 enum CallOrigin { kCalledFromWasm, kCalledFromJS }; 368 369 // Overload for when we want to provide a specific signature, rather than 370 // build one using sig_, for example after scalar lowering. 371 V8_EXPORT_PRIVATE void LowerInt64(Signature<MachineRepresentation>* sig); 372 V8_EXPORT_PRIVATE void LowerInt64(CallOrigin origin); 373 374 V8_EXPORT_PRIVATE void SimdScalarLoweringForTesting(); 375 376 void SetSourcePosition(Node* node, wasm::WasmCodePosition position); 377 378 Node* S128Zero(); 379 Node* S1x4Zero(); 380 Node* S1x8Zero(); 381 Node* S1x16Zero(); 382 383 Node* SimdOp(wasm::WasmOpcode opcode, Node* const* inputs); 384 385 Node* SimdLaneOp(wasm::WasmOpcode opcode, uint8_t lane, Node* const* inputs); 386 387 Node* Simd8x16ShuffleOp(const uint8_t shuffle[16], Node* const* inputs); 388 389 Node* AtomicOp(wasm::WasmOpcode opcode, Node* const* inputs, 390 uint32_t alignment, uint64_t offset, 391 wasm::WasmCodePosition position); 392 Node* AtomicFence(); 393 394 Node* MemoryInit(uint32_t data_segment_index, Node* dst, Node* src, 395 Node* size, wasm::WasmCodePosition position); 396 Node* MemoryCopy(Node* dst, Node* src, Node* size, 397 wasm::WasmCodePosition position); 398 Node* DataDrop(uint32_t data_segment_index, wasm::WasmCodePosition position); 399 Node* MemoryFill(Node* dst, Node* fill, Node* size, 400 wasm::WasmCodePosition position); 401 402 Node* TableInit(uint32_t table_index, uint32_t elem_segment_index, Node* dst, 403 Node* src, Node* size, wasm::WasmCodePosition position); 404 Node* ElemDrop(uint32_t elem_segment_index, wasm::WasmCodePosition position); 405 Node* TableCopy(uint32_t table_dst_index, uint32_t table_src_index, Node* dst, 406 Node* src, Node* size, wasm::WasmCodePosition position); 407 Node* TableGrow(uint32_t table_index, Node* value, Node* delta); 408 Node* TableSize(uint32_t table_index); 409 Node* TableFill(uint32_t table_index, Node* start, Node* value, Node* count); 410 411 Node* StructNewWithRtt(uint32_t struct_index, const wasm::StructType* type, 412 Node* rtt, Vector<Node*> fields); 413 Node* StructGet(Node* struct_object, const wasm::StructType* struct_type, 414 uint32_t field_index, CheckForNull null_check, bool is_signed, 415 wasm::WasmCodePosition position); 416 Node* StructSet(Node* struct_object, const wasm::StructType* struct_type, 417 uint32_t field_index, Node* value, CheckForNull null_check, 418 wasm::WasmCodePosition position); 419 Node* ArrayNewWithRtt(uint32_t array_index, const wasm::ArrayType* type, 420 Node* length, Node* initial_value, Node* rtt); 421 void BoundsCheck(Node* array, Node* index, wasm::WasmCodePosition position); 422 Node* ArrayGet(Node* array_object, const wasm::ArrayType* type, Node* index, 423 CheckForNull null_check, bool is_signed, 424 wasm::WasmCodePosition position); 425 Node* ArraySet(Node* array_object, const wasm::ArrayType* type, Node* index, 426 Node* value, CheckForNull null_check, 427 wasm::WasmCodePosition position); 428 Node* ArrayLen(Node* array_object, wasm::WasmCodePosition position); 429 Node* I31New(Node* input); 430 Node* I31GetS(Node* input); 431 Node* I31GetU(Node* input); 432 Node* RttCanon(wasm::HeapType type); 433 Node* RttSub(wasm::HeapType type, Node* parent_rtt); 434 Node* RefTest(Node* object, Node* rtt, CheckForNull null_check, 435 CheckForI31 i31_check, RttIsI31 rtt_is_i31); 436 Node* RefCast(Node* object, Node* rtt, CheckForNull null_check, 437 CheckForI31 i31_check, RttIsI31 rtt_is_i31, 438 wasm::WasmCodePosition position); 439 Node* BrOnCast(Node* object, Node* rtt, CheckForNull null_check, 440 CheckForI31 i31_check, RttIsI31 rtt_is_i31, 441 Node** match_control, Node** match_effect, 442 Node** no_match_control, Node** no_match_effect); 443 has_simd()444 bool has_simd() const { return has_simd_; } 445 use_trap_handler()446 wasm::UseTrapHandler use_trap_handler() const { 447 return env_ ? env_->use_trap_handler : wasm::kNoTrapHandler; 448 } 449 mcgraph()450 MachineGraph* mcgraph() { return mcgraph_; } 451 Graph* graph(); 452 453 void AddBytecodePositionDecorator(NodeOriginTable* node_origins, 454 wasm::Decoder* decoder); 455 456 void RemoveBytecodePositionDecorator(); 457 458 protected: 459 Node* NoContextConstant(); 460 461 Node* BuildLoadIsolateRoot(); 462 463 // MemBuffer is only called with valid offsets (after bounds checking), so the 464 // offset fits in a platform-dependent uintptr_t. 465 Node* MemBuffer(uintptr_t offset); 466 467 // BoundsCheckMem receives a uint32 {index} node and returns a ptrsize index. 468 Node* BoundsCheckMem(uint8_t access_size, Node* index, uint64_t offset, 469 wasm::WasmCodePosition, EnforceBoundsCheck); 470 // Check that the range [start, start + size) is in the range [0, max). 471 // Also updates *size with the valid range. Returns true if the range is 472 // partially out-of-bounds, traps if it is completely out-of-bounds. 473 Node* BoundsCheckRange(Node* start, Node** size, Node* max, 474 wasm::WasmCodePosition); 475 // BoundsCheckMemRange receives a uint32 {start} and {size}, and checks if it 476 // is in bounds. Also updates *size with the valid range, and converts *start 477 // to a pointer into memory at that index. Returns true if the range is 478 // partially out-of-bounds, traps if it is completely out-of-bounds. 479 Node* BoundsCheckMemRange(Node** start, Node** size, wasm::WasmCodePosition); 480 481 Node* CheckBoundsAndAlignment(int8_t access_size, Node* index, 482 uint64_t offset, wasm::WasmCodePosition); 483 484 Node* Uint32ToUintptr(Node*); 485 const Operator* GetSafeLoadOperator(int offset, wasm::ValueType type); 486 const Operator* GetSafeStoreOperator(int offset, wasm::ValueType type); 487 Node* BuildChangeEndiannessStore(Node* node, MachineRepresentation rep, 488 wasm::ValueType wasmtype = wasm::kWasmStmt); 489 Node* BuildChangeEndiannessLoad(Node* node, MachineType type, 490 wasm::ValueType wasmtype = wasm::kWasmStmt); 491 492 Node* MaskShiftCount32(Node* node); 493 Node* MaskShiftCount64(Node* node); 494 495 enum IsReturnCall : bool { kReturnCall = true, kCallContinues = false }; 496 497 template <typename... Args> 498 Node* BuildCCall(MachineSignature* sig, Node* function, Args... args); 499 Node* BuildCallNode(const wasm::FunctionSig* sig, Vector<Node*> args, 500 wasm::WasmCodePosition position, Node* instance_node, 501 const Operator* op); 502 // Helper function for {BuildIndirectCall}. 503 void LoadIndirectFunctionTable(uint32_t table_index, Node** ift_size, 504 Node** ift_sig_ids, Node** ift_targets, 505 Node** ift_instances); 506 Node* BuildIndirectCall(uint32_t table_index, uint32_t sig_index, 507 Vector<Node*> args, Vector<Node*> rets, 508 wasm::WasmCodePosition position, 509 IsReturnCall continuation); 510 Node* BuildWasmCall(const wasm::FunctionSig* sig, Vector<Node*> args, 511 Vector<Node*> rets, wasm::WasmCodePosition position, 512 Node* instance_node, UseRetpoline use_retpoline); 513 Node* BuildWasmReturnCall(const wasm::FunctionSig* sig, Vector<Node*> args, 514 wasm::WasmCodePosition position, 515 Node* instance_node, UseRetpoline use_retpoline); 516 Node* BuildImportCall(const wasm::FunctionSig* sig, Vector<Node*> args, 517 Vector<Node*> rets, wasm::WasmCodePosition position, 518 int func_index, IsReturnCall continuation); 519 Node* BuildImportCall(const wasm::FunctionSig* sig, Vector<Node*> args, 520 Vector<Node*> rets, wasm::WasmCodePosition position, 521 Node* func_index, IsReturnCall continuation); 522 Node* BuildCallRef(uint32_t sig_index, Vector<Node*> args, Vector<Node*> rets, 523 CheckForNull null_check, IsReturnCall continuation, 524 wasm::WasmCodePosition position); 525 Node* GetBuiltinPointerTarget(int builtin_id); 526 527 Node* BuildF32CopySign(Node* left, Node* right); 528 Node* BuildF64CopySign(Node* left, Node* right); 529 530 Node* BuildIntConvertFloat(Node* input, wasm::WasmCodePosition position, 531 wasm::WasmOpcode); 532 Node* BuildI32Ctz(Node* input); 533 Node* BuildI32Popcnt(Node* input); 534 Node* BuildI64Ctz(Node* input); 535 Node* BuildI64Popcnt(Node* input); 536 Node* BuildBitCountingCall(Node* input, ExternalReference ref, 537 MachineRepresentation input_type); 538 539 Node* BuildCFuncInstruction(ExternalReference ref, MachineType type, 540 Node* input0, Node* input1 = nullptr); 541 Node* BuildF32Trunc(Node* input); 542 Node* BuildF32Floor(Node* input); 543 Node* BuildF32Ceil(Node* input); 544 Node* BuildF32NearestInt(Node* input); 545 Node* BuildF64Trunc(Node* input); 546 Node* BuildF64Floor(Node* input); 547 Node* BuildF64Ceil(Node* input); 548 Node* BuildF64NearestInt(Node* input); 549 Node* BuildI32Rol(Node* left, Node* right); 550 Node* BuildI64Rol(Node* left, Node* right); 551 552 Node* BuildF64Acos(Node* input); 553 Node* BuildF64Asin(Node* input); 554 Node* BuildF64Pow(Node* left, Node* right); 555 Node* BuildF64Mod(Node* left, Node* right); 556 557 Node* BuildIntToFloatConversionInstruction( 558 Node* input, ExternalReference ref, 559 MachineRepresentation parameter_representation, 560 const MachineType result_type); 561 Node* BuildF32SConvertI64(Node* input); 562 Node* BuildF32UConvertI64(Node* input); 563 Node* BuildF64SConvertI64(Node* input); 564 Node* BuildF64UConvertI64(Node* input); 565 566 Node* BuildCcallConvertFloat(Node* input, wasm::WasmCodePosition position, 567 wasm::WasmOpcode opcode); 568 569 Node* BuildI32DivS(Node* left, Node* right, wasm::WasmCodePosition position); 570 Node* BuildI32RemS(Node* left, Node* right, wasm::WasmCodePosition position); 571 Node* BuildI32DivU(Node* left, Node* right, wasm::WasmCodePosition position); 572 Node* BuildI32RemU(Node* left, Node* right, wasm::WasmCodePosition position); 573 574 Node* BuildI64DivS(Node* left, Node* right, wasm::WasmCodePosition position); 575 Node* BuildI64RemS(Node* left, Node* right, wasm::WasmCodePosition position); 576 Node* BuildI64DivU(Node* left, Node* right, wasm::WasmCodePosition position); 577 Node* BuildI64RemU(Node* left, Node* right, wasm::WasmCodePosition position); 578 Node* BuildDiv64Call(Node* left, Node* right, ExternalReference ref, 579 MachineType result_type, wasm::TrapReason trap_zero, 580 wasm::WasmCodePosition position); 581 582 Node* BuildTruncateIntPtrToInt32(Node* value); 583 Node* BuildChangeInt32ToIntPtr(Node* value); 584 Node* BuildChangeInt32ToSmi(Node* value); 585 Node* BuildChangeUint31ToSmi(Node* value); 586 Node* BuildSmiShiftBitsConstant(); 587 Node* BuildSmiShiftBitsConstant32(); 588 Node* BuildChangeSmiToInt32(Node* value); 589 Node* BuildChangeSmiToIntPtr(Node* value); 590 // generates {index > max ? Smi(max) : Smi(index)} 591 Node* BuildConvertUint32ToSmiWithSaturation(Node* index, uint32_t maxval); 592 593 // Asm.js specific functionality. 594 Node* BuildI32AsmjsSConvertF32(Node* input); 595 Node* BuildI32AsmjsSConvertF64(Node* input); 596 Node* BuildI32AsmjsUConvertF32(Node* input); 597 Node* BuildI32AsmjsUConvertF64(Node* input); 598 Node* BuildI32AsmjsDivS(Node* left, Node* right); 599 Node* BuildI32AsmjsRemS(Node* left, Node* right); 600 Node* BuildI32AsmjsDivU(Node* left, Node* right); 601 Node* BuildI32AsmjsRemU(Node* left, Node* right); 602 Node* BuildAsmjsLoadMem(MachineType type, Node* index); 603 Node* BuildAsmjsStoreMem(MachineType type, Node* index, Node* val); 604 605 // Wasm SIMD. 606 Node* BuildF64x2Ceil(Node* input); 607 Node* BuildF64x2Floor(Node* input); 608 Node* BuildF64x2Trunc(Node* input); 609 Node* BuildF64x2NearestInt(Node* input); 610 Node* BuildF32x4Ceil(Node* input); 611 Node* BuildF32x4Floor(Node* input); 612 Node* BuildF32x4Trunc(Node* input); 613 Node* BuildF32x4NearestInt(Node* input); 614 615 void BuildEncodeException32BitValue(Node* values_array, uint32_t* index, 616 Node* value); 617 Node* BuildDecodeException32BitValue(Node* values_array, uint32_t* index); 618 Node* BuildDecodeException64BitValue(Node* values_array, uint32_t* index); 619 620 Node* BuildMultiReturnFixedArrayFromIterable(const wasm::FunctionSig* sig, 621 Node* iterable, Node* context); 622 623 Node* BuildLoadFunctionDataFromJSFunction(Node* closure); 624 Node* BuildLoadJumpTableOffsetFromExportedFunctionData(Node* function_data); 625 Node* BuildLoadFunctionIndexFromExportedFunctionData(Node* function_data); 626 627 //----------------------------------------------------------------------- 628 // Operations involving the CEntry, a dependency we want to remove 629 // to get off the GC heap. 630 //----------------------------------------------------------------------- 631 Node* BuildCallToRuntime(Runtime::FunctionId f, Node** parameters, 632 int parameter_count); 633 634 Node* BuildCallToRuntimeWithContext(Runtime::FunctionId f, Node* js_context, 635 Node** parameters, int parameter_count); 636 TrapId GetTrapIdForTrap(wasm::TrapReason reason); 637 638 void AddInt64LoweringReplacement(CallDescriptor* original, 639 CallDescriptor* replacement); 640 641 CallDescriptor* GetI32AtomicWaitCallDescriptor(); 642 643 CallDescriptor* GetI64AtomicWaitCallDescriptor(); 644 645 Node* StoreArgsInStackSlot( 646 std::initializer_list<std::pair<MachineRepresentation, Node*>> args); 647 648 std::unique_ptr<WasmGraphAssembler> gasm_; 649 Zone* const zone_; 650 MachineGraph* const mcgraph_; 651 wasm::CompilationEnv* const env_; 652 653 WasmInstanceCacheNodes* instance_cache_ = nullptr; 654 655 SetOncePointer<Node> instance_node_; 656 SetOncePointer<Node> globals_start_; 657 SetOncePointer<Node> imported_mutable_globals_; 658 SetOncePointer<Node> stack_check_code_node_; 659 SetOncePointer<Node> isolate_root_node_; 660 SetOncePointer<const Operator> stack_check_call_operator_; 661 662 bool has_simd_ = false; 663 bool needs_stack_check_ = false; 664 const bool untrusted_code_mitigations_ = true; 665 666 const wasm::FunctionSig* const sig_; 667 668 compiler::WasmDecorator* decorator_ = nullptr; 669 670 compiler::SourcePositionTable* const source_position_table_ = nullptr; 671 672 std::unique_ptr<Int64LoweringSpecialCase> lowering_special_case_; 673 CallDescriptor* i32_atomic_wait_descriptor_ = nullptr; 674 CallDescriptor* i64_atomic_wait_descriptor_ = nullptr; 675 }; 676 677 enum WasmCallKind { kWasmFunction, kWasmImportWrapper, kWasmCapiFunction }; 678 679 V8_EXPORT_PRIVATE CallDescriptor* GetWasmCallDescriptor( 680 Zone* zone, const wasm::FunctionSig* signature, 681 WasmGraphBuilder::UseRetpoline use_retpoline = 682 WasmGraphBuilder::kNoRetpoline, 683 WasmCallKind kind = kWasmFunction); 684 685 V8_EXPORT_PRIVATE CallDescriptor* GetI32WasmCallDescriptor( 686 Zone* zone, const CallDescriptor* call_descriptor); 687 688 V8_EXPORT_PRIVATE CallDescriptor* GetI32WasmCallDescriptorForSimd( 689 Zone* zone, CallDescriptor* call_descriptor); 690 691 AssemblerOptions WasmAssemblerOptions(); 692 AssemblerOptions WasmStubAssemblerOptions(); 693 694 } // namespace compiler 695 } // namespace internal 696 } // namespace v8 697 698 #endif // V8_COMPILER_WASM_COMPILER_H_ 699