[wasm] Rename ast-decoder.* to function-body-decoder.*

src/wasm/function-body-decoder.h

 // 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.
 
-#ifndef V8_WASM_AST_DECODER_H_
-#define V8_WASM_AST_DECODER_H_
+#ifndef V8_WASM_FUNCTION_BODY_DECODER_H_
+#define V8_WASM_FUNCTION_BODY_DECODER_H_
 
 #include <iterator>
 
 #include "src/base/compiler-specific.h"
 #include "src/base/iterator.h"
 #include "src/globals.h"
 #include "src/signature.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-opcodes.h"
 #include "src/wasm/wasm-result.h"
@@ skipping 312 matching lines @@
 };
 typedef Result<DecodeStruct*> DecodeResult;
 inline std::ostream& operator<<(std::ostream& os, const DecodeStruct& tree) {
   return os;
 }
 
 V8_EXPORT_PRIVATE DecodeResult VerifyWasmCode(AccountingAllocator* allocator,
                                               FunctionBody& body);
 DecodeResult BuildTFGraph(AccountingAllocator* allocator, TFBuilder* builder,
                           FunctionBody& body);
-bool PrintAst(AccountingAllocator* allocator, const FunctionBody& body,
-              std::ostream& os,
-              std::vector<std::tuple<uint32_t, int, int>>* offset_table);
+bool PrintWasmCode(AccountingAllocator* allocator, const FunctionBody& body,
+                   std::ostream& os,
+                   std::vector<std::tuple<uint32_t, int, int>>* offset_table);

[Clemens Hammacher, 2016/12/21 12:32:42]

At some point I should remove this offset_table. It's not used anymore.

 
 // A simplified form of AST printing, e.g. from a debugger.
-void PrintAstForDebugging(const byte* start, const byte* end);
+void PrintWasmCodeForDebugging(const byte* start, const byte* end);
 
 inline DecodeResult VerifyWasmCode(AccountingAllocator* allocator,
                                    ModuleEnv* module, FunctionSig* sig,
                                    const byte* start, const byte* end) {
   FunctionBody body = {module, sig, nullptr, start, end};
   return VerifyWasmCode(allocator, body);
 }
 
 inline DecodeResult BuildTFGraph(AccountingAllocator* allocator,
                                  TFBuilder* builder, ModuleEnv* module,
                                  FunctionSig* sig, const byte* start,
                                  const byte* end) {
   FunctionBody body = {module, sig, nullptr, start, end};
   return BuildTFGraph(allocator, builder, body);
 }
 
-struct AstLocalDecls {
+struct BodyLocalDecls {
   // The size of the encoded declarations.
   uint32_t decls_encoded_size;  // size of encoded declarations
 
   // Total number of locals.
   uint32_t total_local_count;
 
   // List of {local type, count} pairs.
   ZoneVector<std::pair<LocalType, uint32_t>> local_types;
 
   // Constructor initializes the vector.
-  explicit AstLocalDecls(Zone* zone)
+  explicit BodyLocalDecls(Zone* zone)
       : decls_encoded_size(0), total_local_count(0), local_types(zone) {}
 };
 
-V8_EXPORT_PRIVATE bool DecodeLocalDecls(AstLocalDecls& decls, const byte* start,
-                                        const byte* end);
+V8_EXPORT_PRIVATE bool DecodeLocalDecls(BodyLocalDecls& decls,
+                                        const byte* start, const byte* end);
 V8_EXPORT_PRIVATE BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone,
                                                              size_t num_locals,
                                                              const byte* start,
                                                              const byte* end);
 
 // Computes the length of the opcode at the given address.
 V8_EXPORT_PRIVATE unsigned OpcodeLength(const byte* pc, const byte* end);
 
 // A simple forward iterator for bytecodes.
 class V8_EXPORT_PRIVATE BytecodeIterator : public NON_EXPORTED_BASE(Decoder) {
@@ skipping 49 matching lines @@
     const byte* start_;
     friend class BytecodeIterator;
     offset_iterator(const byte* start, const byte* ptr, const byte* end)
         : iterator_base(ptr, end), start_(start) {}
   };
 
   // Create a new {BytecodeIterator}. If the {decls} pointer is non-null,
   // assume the bytecode starts with local declarations and decode them.
   // Otherwise, do not decode local decls.
   BytecodeIterator(const byte* start, const byte* end,
-                   AstLocalDecls* decls = nullptr);
+                   BodyLocalDecls* decls = nullptr);
 
   base::iterator_range<opcode_iterator> opcodes() {
     return base::iterator_range<opcode_iterator>(opcode_iterator(pc_, end_),
                                                  opcode_iterator(end_, end_));
   }
 
   base::iterator_range<offset_iterator> offsets() {
     return base::iterator_range<offset_iterator>(
         offset_iterator(start_, pc_, end_),
         offset_iterator(start_, end_, end_));
@@ skipping 11 matching lines @@
     }
   }
 
   bool has_next() { return pc_ < end_; }
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
-#endif  // V8_WASM_AST_DECODER_H_
+#endif  // V8_WASM_FUNCTION_BODY_DECODER_H_