[type profile] Collect return types.

src/ast/ast.h

 // Copyright 2012 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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 877 matching lines @@
  private:
   friend class AstNodeFactory;
 
   BreakStatement(BreakableStatement* target, int pos)
       : JumpStatement(pos, kBreakStatement), target_(target) {}
 
   BreakableStatement* target_;
 };
 
 
 class ReturnStatement final : public JumpStatement {

[Michael Starzinger, 2017/03/20 09:29:26]

High level remark: Note that the implicit return value when one falls off the
function end is not captured by the AST. That means e.g. function not containing
any explicit "return" statement does not contain any {ReturnStatement} AST node,
the fall-off return instruction is added individually by the various compilers.

Also, any "yield" point within generator functions is not covered by this
either. But I assume that is actually working as intended.

[Yang, 2017/03/20 10:07:23]

So if the function only has a fall-off return, the observed type is "undefined"
by definition, right?

[Franzi, 2017/03/20 15:38:39]

Oh, I didn't think of fall-off returns. If they happen, then "undefined" should
definitely be added to the types. 

Is it OK to do that in a follow up CL? In the current form, for a fall-off
return, "VisitReturnStatement" is not called, so the CollectTypeProfile bytecode
is not emitted, and it's only that "undefined" is missing in the list of types,
not that anything crashes, right? 

[Michael Starzinger, 2017/03/20 17:12:32]

Acknowledged. Totally fine with this being done later in a separate CL. Yes,
should only cause "missing feedback", no crashes or anything scary like that.

  public:
   enum Type { kNormal, kAsyncReturn };
   Expression* expression() const { return expression_; }
 
   void set_expression(Expression* e) { expression_ = e; }
   Type type() const { return TypeField::decode(bit_field_); }
   bool is_async_return() const { return type() == kAsyncReturn; }
 
+  FeedbackSlot TypeProfileSlot() const {
+    DCHECK(HasTypeProfileSlot());
+    return type_profile_slot_;
+  }
+
+  void SetTypeProfileSlot(FeedbackSlot slot) { type_profile_slot_ = slot; }
+
+  bool HasTypeProfileSlot() const { return !type_profile_slot_.IsInvalid(); }
+
  private:
   friend class AstNodeFactory;
 
   ReturnStatement(Expression* expression, Type type, int pos)
       : JumpStatement(pos, kReturnStatement), expression_(expression) {
     bit_field_ |= TypeField::encode(type);
   }
 
+  FeedbackSlot type_profile_slot_;
+
   Expression* expression_;
 
   class TypeField
       : public BitField<Type, JumpStatement::kNextBitFieldIndex, 1> {};
 };
 
 
 class WithStatement final : public Statement {
  public:
   Scope* scope() { return scope_; }
@@ skipping 2722 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_