[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 700 matching lines @@
           if (count == 0) {
             BUILD(Return, 0, builder_->Buffer(0));
             ssa_env_->Kill();
             Leaf(kAstEnd);
           } else {
             Shift(kAstEnd, count);
           }
           break;
         }
         case kExprUnreachable: {
-          // TODO(clemensh): add source position for unreachable
-          BUILD0(Unreachable);
+          BUILD(Unreachable, current_position());
           ssa_env_->Kill(SsaEnv::kControlEnd);
           Leaf(kAstEnd, nullptr);
           break;
         }
         case kExprI8Const: {
           ImmI8Operand operand(this, pc_);
           Leaf(kAstI32, BUILD(Int32Constant, operand.value));
           len = 1 + operand.length;
           break;
         }
@@ skipping 52 matching lines @@
             Shift(operand.type, 1);
           }
           len = 1 + operand.length;
           break;
         }
         case kExprI32LoadMem8S:
         case kExprI32LoadMem8U:
         case kExprI32LoadMem16S:
         case kExprI32LoadMem16U:
         case kExprI32LoadMem:
-          len = DecodeLoadMem(pc_, kAstI32);
+          len = DecodeLoadMem(kAstI32);
           break;
         case kExprI64LoadMem8S:
         case kExprI64LoadMem8U:
         case kExprI64LoadMem16S:
         case kExprI64LoadMem16U:
         case kExprI64LoadMem32S:
         case kExprI64LoadMem32U:
         case kExprI64LoadMem:
-          len = DecodeLoadMem(pc_, kAstI64);
+          len = DecodeLoadMem(kAstI64);
           break;
         case kExprF32LoadMem:
-          len = DecodeLoadMem(pc_, kAstF32);
+          len = DecodeLoadMem(kAstF32);
           break;
         case kExprF64LoadMem:
-          len = DecodeLoadMem(pc_, kAstF64);
+          len = DecodeLoadMem(kAstF64);
           break;
         case kExprI32StoreMem8:
         case kExprI32StoreMem16:
         case kExprI32StoreMem:
-          len = DecodeStoreMem(pc_, kAstI32);
+          len = DecodeStoreMem(kAstI32);
           break;
         case kExprI64StoreMem8:
         case kExprI64StoreMem16:
         case kExprI64StoreMem32:
         case kExprI64StoreMem:
-          len = DecodeStoreMem(pc_, kAstI64);
+          len = DecodeStoreMem(kAstI64);
           break;
         case kExprF32StoreMem:
-          len = DecodeStoreMem(pc_, kAstF32);
+          len = DecodeStoreMem(kAstF32);
           break;
         case kExprF64StoreMem:
-          len = DecodeStoreMem(pc_, kAstF64);
+          len = DecodeStoreMem(kAstF64);
           break;
         case kExprMemorySize:
           Leaf(kAstI32, BUILD(MemSize, 0));
           break;
         case kExprGrowMemory:
           Shift(kAstI32, 1);
           break;
         case kExprCallFunction: {
           FunctionIndexOperand operand(this, pc_);
           if (Validate(pc_, operand)) {
@@ skipping 40 matching lines @@
         }
         return;
       }
     }
   }
 
   void PushBlock(SsaEnv* ssa_env) {
     blocks_.push_back({ssa_env, static_cast<int>(stack_.size() - 1)});
   }
 
-  int DecodeLoadMem(const byte* pc, LocalType type) {
-    MemoryAccessOperand operand(this, pc);
+  int DecodeLoadMem(LocalType type) {
+    MemoryAccessOperand operand(this, pc_);
     Shift(type, 1);
     return 1 + operand.length;
   }
 
-  int DecodeStoreMem(const byte* pc, LocalType type) {
-    MemoryAccessOperand operand(this, pc);
+  int DecodeStoreMem(LocalType type) {
+    MemoryAccessOperand operand(this, pc_);
     Shift(type, 2);
     return 1 + operand.length;
   }
 
   void AddImplicitReturnAtEnd() {
     int retcount = static_cast<int>(sig_->return_count());
     if (retcount == 0) {
       BUILD0(ReturnVoid);
       return;
     }
@@ skipping 35 matching lines @@
     WasmOpcode opcode = p->opcode();
     TRACE("-----reduce module+%-6d %s func+%d: 0x%02x %s\n", baserel(p->pc()),
           indentation(), startrel(p->pc()), opcode,
           WasmOpcodes::OpcodeName(opcode));
     FunctionSig* sig = WasmOpcodes::Signature(opcode);
     if (sig) {
       // A simple expression with a fixed signature.
       TypeCheckLast(p, sig->GetParam(p->index - 1));
       if (p->done() && build()) {
         if (sig->parameter_count() == 2) {
-          p->tree->node = builder_->Binop(opcode, p->tree->children[0]->node,
-                                          p->tree->children[1]->node);
+          p->tree->node =
+              builder_->Binop(opcode, p->tree->children[0]->node,
+                              p->tree->children[1]->node, position(p));
         } else if (sig->parameter_count() == 1) {
-          p->tree->node = builder_->Unop(opcode, p->tree->children[0]->node);
+          p->tree->node =
+              builder_->Unop(opcode, p->tree->children[0]->node, position(p));
         } else {
           UNREACHABLE();
         }
       }
       return;
     }
 
     switch (opcode) {
       case kExprBlock: {
         if (p->done()) {
@@ skipping 282 matching lines @@
           TypeCheckLast(p, kAstI32);
         } else {
           TypeCheckLast(p, operand.sig->GetParam(p->index - 2));
         }
         if (p->done() && build()) {
           uint32_t count = p->tree->count;
           TFNode** buffer = builder_->Buffer(count);
           for (uint32_t i = 0; i < count; i++) {
             buffer[i] = p->tree->children[i]->node;
           }
-          p->tree->node = builder_->CallIndirect(operand.index, buffer);
+          p->tree->node =
+              builder_->CallIndirect(operand.index, buffer, position(p));
           AddSourcePosition(p);
         }
         break;
       }
       case kExprCallImport: {
         ImportIndexOperand operand(this, p->pc());
         CHECK(Validate(p->pc(), operand));
         if (p->index > 0) {
           TypeCheckLast(p, operand.sig->GetParam(p->index - 1));
         }
@@ skipping 52 matching lines @@
                                              p->tree->node, expr->node);
       }
     }
   }
 
   void ReduceLoadMem(Production* p, LocalType type, MachineType mem_type) {
     DCHECK_EQ(1, p->index);
     TypeCheckLast(p, kAstI32);  // index
     if (build()) {
       MemoryAccessOperand operand(this, p->pc());
-      p->tree->node =
-          builder_->LoadMem(type, mem_type, p->last()->node, operand.offset);
+      p->tree->node = builder_->LoadMem(type, mem_type, p->last()->node,
+                                        operand.offset, position(p));
     }
   }
 
   void ReduceStoreMem(Production* p, LocalType type, MachineType mem_type) {
     if (p->index == 1) {
       TypeCheckLast(p, kAstI32);  // index
     } else {
       DCHECK_EQ(2, p->index);
       TypeCheckLast(p, type);
       if (build()) {
         MemoryAccessOperand operand(this, p->pc());
         TFNode* val = p->tree->children[1]->node;
         builder_->StoreMem(mem_type, p->tree->children[0]->node, operand.offset,
-                           val);
+                           val, position(p));
         p->tree->node = val;
       }
     }
   }
 
   void TypeCheckLast(Production* p, LocalType expected) {
     LocalType result = p->last()->type;
     if (result == expected) return;
     if (result == kAstEnd) return;
     if (expected != kAstStmt) {
@@ skipping 57 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 157 matching lines @@
       arity_stack.push_back(arity);
       while (arity_stack.back() == 0) {
         arity_stack.pop_back();
         if (arity_stack.empty()) return assigned;  // reached end of loop
         arity_stack.back()--;
       }
     }
     return assigned;
   }
 
-  void AddSourcePosition(Production* p) {
+  inline void AddSourcePosition(Production* p) {
     DCHECK_NOT_NULL(p->tree->node);
-    AddSourcePosition(p->tree->node, p->pc());
+    builder_->SetSourcePosition(p->tree->node, position(p));
   }
 
-  void AddSourcePosition(TFNode* node, const byte* pc) {
+  inline int current_position() { return position(pc_); }

[titzer, 2016/04/28 11:27:00]

Let's inline this one, since it's not actually shorter than its body.

[Clemens Hammacher, 2016/04/28 12:43:28]

.. and it just had one usage.
Done.

+  inline int position(Production* p) { return position(p->pc()); }
+  inline int position(const byte* pc) {
     int offset = static_cast<int>(pc - start_);
     DCHECK_EQ(pc - start_, offset);  // overflows cannot happen
-    builder_->SetSourcePosition(node, offset);
+    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