[wasm] Generate source position information

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);
           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 216 matching lines @@
       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);
         } else if (sig->parameter_count() == 1) {
           p->tree->node = builder_->Unop(opcode, p->tree->children[0]->node);
         } else {
           UNREACHABLE();
         }
+        if (IsSimpleOpTrapping(p->opcode())) AddSourcePosition(p);
       }
       return;
     }
 
     switch (opcode) {
       case kExprBlock: {
         if (p->done()) {
           Block* last = &blocks_.back();
           DCHECK_EQ(stack_.size() - 1, last->stack_depth);
           // fallthrough with the last expression.
@@ skipping 261 matching lines @@
           TypeCheckLast(p, operand.sig->GetParam(p->index - 1));
         }
         if (p->done() && build()) {
           uint32_t count = p->tree->count + 1;
           TFNode** buffer = builder_->Buffer(count);
           buffer[0] = nullptr;  // reserved for code object.
           for (uint32_t i = 1; i < count; i++) {
             buffer[i] = p->tree->children[i - 1]->node;
           }
           p->tree->node = builder_->CallDirect(operand.index, buffer);
+          AddSourcePosition(p);
         }
         break;
       }
       case kExprCallIndirect: {
         SignatureIndexOperand operand(this, p->pc());
         CHECK(Validate(p->pc(), operand));
         if (p->index == 1) {
           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);
+          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));
         }
         if (p->done() && build()) {
           uint32_t count = p->tree->count + 1;
           TFNode** buffer = builder_->Buffer(count);
           buffer[0] = nullptr;  // reserved for code object.
           for (uint32_t i = 1; i < count; i++) {
             buffer[i] = p->tree->children[i - 1]->node;
           }
           p->tree->node = builder_->CallImport(operand.index, buffer);
+          AddSourcePosition(p);
         }
         break;
       }
       default:
         break;
     }
   }
 
   void ReduceBreakToExprBlock(Production* p, Block* block) {
     ReduceBreakToExprBlock(p, block, p->tree->count > 0 ? p->last() : nullptr);
@@ skipping 35 matching lines @@
     }
   }
 
   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);
+      AddSourcePosition(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);
         p->tree->node = val;
+        AddSourcePosition(p);
       }
     }
   }
 
   void TypeCheckLast(Production* p, LocalType expected) {
     LocalType result = p->last()->type;
     if (result == expected) return;
     if (result == kAstEnd) return;
     if (expected != kAstStmt) {
       error(p->pc(), p->last()->pc,
@@ skipping 271 matching lines @@
       pc += length;
       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) {
+    DCHECK_NOT_NULL(p->tree->node);
+    AddSourcePosition(p->tree->node, p->pc());
+  }
+
+  void AddSourcePosition(TFNode* node, const byte* pc) {
+    int offset = static_cast<int>(pc - start_);
+    DCHECK_EQ(pc - start_, offset);  // overflows cannot happen
+    builder_->SetSourcePosition(node, offset);
+  }
+
+  bool IsSimpleOpTrapping(WasmOpcode opcode) {
+    switch (opcode) {
+#define V(name) case WasmOpcode::kExpr##name:
+      FOREACH_SIMPLE_TRAPPING_OPCODE(V)
+#undef V
+      return true;
+      default:
+        return false;
+    }
+  }
 };
 
 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 132 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