[wasm] Pass byte position for trapping instructions

src/wasm/ast-decoder.cc

 // Copyright 2015 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/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 597 matching lines @@
       TRACE("  @%-6d #%02x:%-20s|", startrel(pc_), opcode,
             WasmOpcodes::ShortOpcodeName(opcode));
 
       FunctionSig* sig = WasmOpcodes::Signature(opcode);
       if (sig) {
         // Fast case of a simple operator.
         TFNode* node;
         switch (sig->parameter_count()) {
           case 1: {
             Value val = Pop(0, sig->GetParam(0));
-            node = BUILD(Unop, opcode, val.node);
+            node = BUILD(Unop, opcode, val.node, position());
             break;
           }
           case 2: {
             Value rval = Pop(1, sig->GetParam(1));
             Value lval = Pop(0, sig->GetParam(0));
-            node = BUILD(Binop, opcode, lval.node, rval.node);
+            node = BUILD(Binop, opcode, lval.node, rval.node, position());
             break;
           }
           default:
             UNREACHABLE();
             node = nullptr;
             break;
         }
         Push(GetReturnType(sig), node);
       } else {
         // Complex bytecode.
@@ skipping 187 matching lines @@
           case kExprReturn: {
             ReturnArityOperand operand(this, pc_);
             if (operand.arity != sig_->return_count()) {
               error(pc_, pc_ + 1, "arity mismatch in return");
             }
             DoReturn();
             len = 1 + operand.length;
             break;
           }
           case kExprUnreachable: {
-            // TODO(clemensh): add source position for unreachable
-            Push(kAstEnd, BUILD0(Unreachable));
+            Push(kAstEnd, BUILD(Unreachable, position()));
             ssa_env_->Kill(SsaEnv::kControlEnd);
             break;
           }
           case kExprI8Const: {
             ImmI8Operand operand(this, pc_);
             Push(kAstI32, BUILD(Int32Constant, operand.value));
             len = 1 + operand.length;
             break;
           }
           case kExprI32Const: {
@@ skipping 137 matching lines @@
           case kExprGrowMemory: {
             Value val = Pop(0, kAstI32);
             USE(val);  // TODO(titzer): build node for grow memory
             Push(kAstI32, BUILD(Int32Constant, 0));
             break;
           }
           case kExprCallFunction: {
             CallFunctionOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               TFNode** buffer = PopArgs(operand.sig);
-              TFNode* call = BUILD(CallDirect, operand.index, buffer);
+              TFNode* call =
+                  BUILD(CallDirect, operand.index, buffer, position());
               Push(GetReturnType(operand.sig), call);
-              AddSourcePosition(call, pc_);
             }
             len = 1 + operand.length;
             break;
           }
           case kExprCallIndirect: {
             CallIndirectOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               TFNode** buffer = PopArgs(operand.sig);
               Value index = Pop(0, kAstI32);
               if (buffer) buffer[0] = index.node;
-              TFNode* call = BUILD(CallIndirect, operand.index, buffer);
+              TFNode* call =
+                  BUILD(CallIndirect, operand.index, buffer, position());
               Push(GetReturnType(operand.sig), call);
-              AddSourcePosition(call, pc_);
             }
             len = 1 + operand.length;
             break;
           }
           case kExprCallImport: {
             CallImportOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               TFNode** buffer = PopArgs(operand.sig);
-              TFNode* call = BUILD(CallImport, operand.index, buffer);
+              TFNode* call =
+                  BUILD(CallImport, operand.index, buffer, position());
               Push(GetReturnType(operand.sig), call);
-              AddSourcePosition(call, pc_);
             }
             len = 1 + operand.length;
             break;
           }
           default:
             error("Invalid opcode");
             return;
         }
       }  // end complex bytecode
 
@@ skipping 73 matching lines @@
 
   void PushIf(SsaEnv* end_env, SsaEnv* false_env) {
     int stack_depth = static_cast<int>(stack_.size());
     control_.push_back(
         {pc_, stack_depth, end_env, false_env, nullptr, kAstStmt, false});
   }
 
   int DecodeLoadMem(LocalType type, MachineType mem_type) {
     MemoryAccessOperand operand(this, pc_);
     Value index = Pop(0, kAstI32);
-    TFNode* node = BUILD(LoadMem, type, mem_type, index.node, operand.offset);
+    TFNode* node =
+        BUILD(LoadMem, type, mem_type, index.node, operand.offset, position());
     Push(type, node);
     return 1 + operand.length;
   }
 
   int DecodeStoreMem(LocalType type, MachineType mem_type) {
     MemoryAccessOperand operand(this, pc_);
     Value val = Pop(1, type);
     Value index = Pop(0, kAstI32);
-    BUILD(StoreMem, mem_type, index.node, operand.offset, val.node);
+    BUILD(StoreMem, mem_type, index.node, operand.offset, val.node, position());
     Push(type, val.node);
     return 1 + operand.length;
   }
 
   void DoReturn() {
     int count = static_cast<int>(sig_->return_count());
     TFNode** buffer = nullptr;
     if (build()) buffer = builder_->Buffer(count);
 
     // Pop return values off the stack in reverse order.
@@ skipping 157 matching lines @@
         }
         break;
       }
       case SsaEnv::kMerged: {
         if (!builder_) break;
         TFNode* merge = to->control;
         // Extend the existing merge.
         builder_->AppendToMerge(merge, from->control);
         // Merge effects.
         if (builder_->IsPhiWithMerge(to->effect, merge)) {
-          builder_->AppendToPhi(merge, to->effect, from->effect);
+          builder_->AppendToPhi(to->effect, from->effect);
         } else if (to->effect != from->effect) {
           uint32_t count = builder_->InputCount(merge);
           TFNode** effects = builder_->Buffer(count);
           for (uint32_t j = 0; j < count - 1; j++) {
             effects[j] = to->effect;
           }
           effects[count - 1] = from->effect;
           to->effect = builder_->EffectPhi(count, effects, merge);
         }
         // Merge locals.
         for (int i = EnvironmentCount() - 1; i >= 0; i--) {
           TFNode* tnode = to->locals[i];
           TFNode* fnode = from->locals[i];
           if (builder_->IsPhiWithMerge(tnode, merge)) {
-            builder_->AppendToPhi(merge, tnode, fnode);
+            builder_->AppendToPhi(tnode, fnode);
           } else if (tnode != fnode) {
             uint32_t count = builder_->InputCount(merge);
             TFNode** vals = builder_->Buffer(count);
             for (uint32_t j = 0; j < count - 1; j++) {
               vals[j] = tnode;
             }
             vals[count - 1] = fnode;
             to->locals[i] =
                 builder_->Phi(local_type_vec_[i], count, vals, merge);
           }
         }
         break;
       }
       default:
         UNREACHABLE();
     }
     return from->Kill();
   }
 
   TFNode* CreateOrMergeIntoPhi(LocalType type, TFNode* merge, TFNode* tnode,
                                TFNode* fnode) {
     if (builder_->IsPhiWithMerge(tnode, merge)) {
-      builder_->AppendToPhi(merge, tnode, fnode);
+      builder_->AppendToPhi(tnode, fnode);
     } else if (tnode != fnode) {
       uint32_t count = builder_->InputCount(merge);
       TFNode** vals = builder_->Buffer(count);
       for (uint32_t j = 0; j < count - 1; j++) vals[j] = tnode;
       vals[count - 1] = fnode;
       return builder_->Phi(type, count, vals, merge);
     }
     return tnode;
   }
 
@@ skipping 114 matching lines @@
         default:
           length = OpcodeLength(pc);
           break;
       }
       if (depth <= 0) break;
       pc += length;
     }
     return assigned;
   }
 
-  void AddSourcePosition(TFNode* node, const byte* pc) {
-    if (node) {
-      int offset = static_cast<int>(pc - start_);
-      DCHECK_EQ(pc - start_, offset);  // overflows cannot happen
-      builder_->SetSourcePosition(node, offset);
-    }
+  inline wasm::WasmCodePosition position() {
+    int offset = static_cast<int>(pc_ - start_);
+    DCHECK_EQ(pc_ - start_, offset);  // overflows cannot happen
+    return offset;
   }
 };
 
 bool DecodeLocalDecls(AstLocalDecls& decls, const byte* start,
                       const byte* end) {
   base::AccountingAllocator allocator;
   Zone tmp(&allocator);
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   SR_WasmDecoder decoder(&tmp, nullptr, body);
   return decoder.DecodeLocalDecls(decls);
@@ skipping 133 matching lines @@
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   SR_WasmDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8