[csa] Add Unreachable() and use it after throw sites

src/builtins/builtins-promise.cc

 // Copyright 2016 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/builtins/builtins-promise.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
@@ skipping 160 matching lines @@
 
     Bind(&if_notcallable);
     Node* message = SmiConstant(MessageTemplate::kPromiseNonCallable);
     StoreObjectField(capability, JSPromiseCapability::kPromiseOffset,
                      UndefinedConstant());
     StoreObjectField(capability, JSPromiseCapability::kResolveOffset,
                      UndefinedConstant());
     StoreObjectField(capability, JSPromiseCapability::kRejectOffset,
                      UndefinedConstant());
     CallRuntime(Runtime::kThrowTypeError, context, message);
-    var_result.Bind(UndefinedConstant());
-    Goto(&out);
+    Unreachable();
   }
 
   Bind(&out);
   return var_result.value();
 }
 
 Node* PromiseBuiltinsAssembler::CreatePromiseContext(Node* native_context,
                                                      int slots) {
   DCHECK_GE(slots, Context::MIN_CONTEXT_SLOTS);
 
@@ skipping 51 matching lines @@
   // The {value} is not a compatible receiver for this method.
   Bind(&throw_exception);
   {
     Node* const method =
         method_name == nullptr
             ? UndefinedConstant()
             : HeapConstant(
                   isolate()->factory()->NewStringFromAsciiChecked(method_name));
     Node* const message_id = SmiConstant(msg_template);
     CallRuntime(Runtime::kThrowTypeError, context, message_id, method);
-    var_value_map.Bind(UndefinedConstant());
-    Goto(&out);  // Never reached.
+    Unreachable();
   }
 
   Bind(&out);
   return var_value_map.value();
 }
 
 Node* PromiseBuiltinsAssembler::PromiseHasHandler(Node* promise) {
   Node* const flags = LoadObjectField(promise, JSPromise::kFlagsOffset);
   return IsSetWord(SmiUntag(flags), 1 << JSPromise::kHasHandlerBit);
 }
@@ skipping 52 matching lines @@
             &throw_error);
   var_result.Bind(species);
   Goto(&out);
 
   // 8. Throw a TypeError exception.
   Bind(&throw_error);
   {
     Node* const message_id =
         SmiConstant(MessageTemplate::kSpeciesNotConstructor);
     CallRuntime(Runtime::kThrowTypeError, context, message_id);
-    Goto(&out);
+    Unreachable();
   }
 
   Bind(&out);
   return var_result.value();
 }
 
 void PromiseBuiltinsAssembler::AppendPromiseCallback(int offset, Node* promise,
                                                      Node* value) {
   Node* elements = LoadObjectField(promise, offset);
   Node* length = LoadFixedArrayBaseLength(elements);
@@ skipping 769 matching lines @@
     }
     Bind(&out);
     Return(var_result.value());
   }
 
   // 1. If NewTarget is undefined, throw a TypeError exception.
   Bind(&if_targetisundefined);
   {
     Node* const message_id = SmiConstant(MessageTemplate::kNotAPromise);
     CallRuntime(Runtime::kThrowTypeError, context, message_id, new_target);
-    Return(UndefinedConstant());  // Never reached.
+    Unreachable();
   }
 
   // 2. If IsCallable(executor) is false, throw a TypeError exception.
   Bind(&if_notcallable);
   {
     Node* const message_id =
         SmiConstant(MessageTemplate::kResolverNotAFunction);
     CallRuntime(Runtime::kThrowTypeError, context, message_id, executor);
-    Return(UndefinedConstant());  // Never reached.
+    Unreachable();
   }
 
   // Silently fail if the stack looks fishy.
   Bind(&if_noaccess);
   {
     Node* const counter_id =
         SmiConstant(v8::Isolate::kPromiseConstructorReturnedUndefined);
     CallRuntime(Runtime::kIncrementUseCounter, context, counter_id);
     Return(UndefinedConstant());
   }
@@ skipping 350 matching lines @@
              UndefinedConstant()),
          &if_alreadyinvoked);
 
   StoreObjectField(capability, JSPromiseCapability::kResolveOffset, resolve);
   StoreObjectField(capability, JSPromiseCapability::kRejectOffset, reject);
 
   Return(UndefinedConstant());
 
   Bind(&if_alreadyinvoked);
   Node* message = SmiConstant(MessageTemplate::kPromiseExecutorAlreadyInvoked);
-  Return(CallRuntime(Runtime::kThrowTypeError, context, message));
+  CallRuntime(Runtime::kThrowTypeError, context, message);
+  Unreachable();
 }
 
 TF_BUILTIN(NewPromiseCapability, PromiseBuiltinsAssembler) {
   Node* constructor = Parameter(1);
   Node* debug_event = Parameter(2);
   Node* context = Parameter(5);
 
   CSA_ASSERT_JS_ARGC_EQ(this, 2);
 
   Return(NewPromiseCapability(context, constructor, debug_event));
@@ skipping 136 matching lines @@
                              promise_capability, UndefinedConstant(),
                              UndefinedConstant());
   Return(promise_capability);
 }
 
 TF_BUILTIN(PromiseThrowerFinally, PromiseBuiltinsAssembler) {
   Node* const context = Parameter(3);
 
   Node* const reason = LoadContextElement(context, kOnFinallySlot);
   CallRuntime(Runtime::kThrow, context, reason);
-  Return(UndefinedConstant());
+  Unreachable();
 }
 
 Node* PromiseBuiltinsAssembler::CreateThrowerFunctionContext(
     Node* reason, Node* native_context) {
   Node* const context =
       CreatePromiseContext(native_context, kOnFinallyContextLength);
   StoreContextElementNoWriteBarrier(context, kOnFinallySlot, reason);
   return context;
 }
 
@@ skipping 107 matching lines @@
     // 5. Return ?  Invoke(promise, "then", « thenFinally, catchFinally »).
     Node* const result =
         CallJS(call_callable, context, then, promise, var_then_finally.value(),
                var_catch_finally.value());
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8