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

src/code-stub-assembler.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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 2676 matching lines @@
           Goto(&if_valueisstring);
         }
       }
 
       Bind(&if_valueisnullorundefined);
       {
         // The {value} is either null or undefined.
         CallRuntime(Runtime::kThrowCalledOnNullOrUndefined, context,
                     HeapConstant(factory()->NewStringFromAsciiChecked(
                         method_name, TENURED)));
-        Goto(&if_valueisstring);  // Never reached.
+        Unreachable();
       }
     }
   }
   Bind(&if_valueissmi);
   {
     // The {value} is a Smi, convert it to a String.
     Callable callable = CodeFactory::NumberToString(isolate());
     var_value.Bind(CallStub(callable, context, value));
     Goto(&if_valueisstring);
   }
@@ skipping 78 matching lines @@
       Goto(&done_throw);
     }
   }
 
   Bind(&done_throw);
   {
     // The {value} is not a compatible receiver for this method.
     CallRuntime(Runtime::kThrowNotGeneric, context,
                 HeapConstant(factory()->NewStringFromAsciiChecked(method_name,
                                                                   TENURED)));
-    Goto(&done_loop);  // Never reached.
+    Unreachable();
   }
 
   Bind(&done_loop);
   return var_value.value();
 }
 
 Node* CodeStubAssembler::ThrowIfNotInstanceType(Node* context, Node* value,
                                                 InstanceType instance_type,
                                                 char const* method_name) {
   Label out(this), throw_exception(this, Label::kDeferred);
   Variable var_value_map(this, MachineRepresentation::kTagged);
 
   GotoIf(TaggedIsSmi(value), &throw_exception);
 
   // Load the instance type of the {value}.
   var_value_map.Bind(LoadMap(value));
   Node* const value_instance_type = LoadMapInstanceType(var_value_map.value());
 
   Branch(Word32Equal(value_instance_type, Int32Constant(instance_type)), &out,
          &throw_exception);
 
   // The {value} is not a compatible receiver for this method.
   Bind(&throw_exception);
   CallRuntime(
       Runtime::kThrowIncompatibleMethodReceiver, context,
       HeapConstant(factory()->NewStringFromAsciiChecked(method_name, TENURED)),
       value);
-  var_value_map.Bind(UndefinedConstant());
-  Goto(&out);  // Never reached.
+  Unreachable();
 
   Bind(&out);
   return var_value_map.value();
 }
 
 Node* CodeStubAssembler::InstanceTypeEqual(Node* instance_type, int type) {
   return Word32Equal(instance_type, Int32Constant(type));
 }
 
 Node* CodeStubAssembler::IsSpecialReceiverMap(Node* map) {
@@ skipping 4966 matching lines @@
   Node* map = LoadMap(active_function);
   Node* prototype = LoadMapPrototype(map);
   Node* prototype_map = LoadMap(prototype);
   GotoIfNot(IsConstructorMap(prototype_map), &is_not_constructor);
 
   result.Bind(prototype);
   Goto(&out);
 
   Bind(&is_not_constructor);
   {
-    result.Bind(CallRuntime(Runtime::kThrowNotSuperConstructor, context,
-                            prototype, active_function));
-    Goto(&out);
+    CallRuntime(Runtime::kThrowNotSuperConstructor, context, prototype,
+                active_function);
+    Unreachable();
   }
 
   Bind(&out);
   return result.value();
 }
 
 Node* CodeStubAssembler::InstanceOf(Node* object, Node* callable,
                                     Node* context) {
   Variable var_result(this, MachineRepresentation::kTagged);
   Label if_notcallable(this, Label::kDeferred),
@@ skipping 48 matching lines @@
 
     // Use the OrdinaryHasInstance algorithm.
     Node* result = CallStub(CodeFactory::OrdinaryHasInstance(isolate()),
                             context, callable, object);
     var_result.Bind(result);
     Goto(&return_result);
   }
 
   Bind(&if_notcallable);
   {
-    Node* result =
-        CallRuntime(Runtime::kThrowNonCallableInInstanceOfCheck, context);
-    var_result.Bind(result);
-    Goto(&return_result);
+    CallRuntime(Runtime::kThrowNonCallableInInstanceOfCheck, context);
+    Unreachable();
   }
 
   Bind(&if_notreceiver);
   {
-    Node* result =
-        CallRuntime(Runtime::kThrowNonObjectInInstanceOfCheck, context);
-    var_result.Bind(result);
-    Goto(&return_result);
+    CallRuntime(Runtime::kThrowNonObjectInInstanceOfCheck, context);
+    Unreachable();
   }
 
   Bind(&return_true);
   var_result.Bind(TrueConstant());
   Goto(&return_result);
 
   Bind(&return_false);
   var_result.Bind(FalseConstant());
   Goto(&return_result);
 
@@ skipping 472 matching lines @@
         formatted.c_str(), TENURED);
     CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
                 HeapConstant(string));
   }
   CallRuntime(Runtime::kDebugPrint, NoContextConstant(), tagged_value);
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8