Reland: Introduce a V8_NORETURN macro and use it to make GCC 4.9.2 happy again.

Without that, it has a few false positives about out-of-bounds array accesses.
Also makes the clang static-analyzer happy.

Original code review from Sven Panne:
https://codereview.chromium.org/790723002/

CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux_arm_dbg,v8_linux_arm64_dbg,v8_mac64_dbg,v8_win_compile_dbg

Review URL: https://codereview.chromium.org/1383053005

Cr-Commit-Position: refs/heads/master@{#31163}

include/v8config.h

@@ -174,6 +174,7 @@
 //                                        supported
 //  V8_HAS_ATTRIBUTE_DEPRECATED         - __attribute__((deprecated)) supported
 //  V8_HAS_ATTRIBUTE_NOINLINE           - __attribute__((noinline)) supported
+//  V8_HAS_ATTRIBUTE_NORETURN           - __attribute__((noreturn)) supported
 //  V8_HAS_ATTRIBUTE_UNUSED             - __attribute__((unused)) supported
 //  V8_HAS_ATTRIBUTE_VISIBILITY         - __attribute__((visibility)) supported
 //  V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT - __attribute__((warn_unused_result))
@@ -190,6 +191,7 @@
 //  V8_HAS_DECLSPEC_DEPRECATED          - __declspec(deprecated) supported
 //  V8_HAS_DECLSPEC_NOINLINE            - __declspec(noinline) supported
 //  V8_HAS_DECLSPEC_SELECTANY           - __declspec(selectany) supported
+//  V8_HAS_DECLSPEC_NORETURN            - __declspec(noreturn) supported
 //  V8_HAS___FORCEINLINE                - __forceinline supported
 //
 // Note that testing for compilers and/or features must be done using #if
@@ -212,6 +214,7 @@
 # define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (__has_attribute(always_inline))
 # define V8_HAS_ATTRIBUTE_DEPRECATED (__has_attribute(deprecated))
 # define V8_HAS_ATTRIBUTE_NOINLINE (__has_attribute(noinline))
+# define V8_HAS_ATTRIBUTE_NORETURN (__has_attribute(noreturn))
 # define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused))
 # define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility))
 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \
@@ -253,6 +256,7 @@
 # define V8_HAS_ATTRIBUTE_DEPRECATED (V8_GNUC_PREREQ(3, 4, 0))
 # define V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE (V8_GNUC_PREREQ(4, 5, 0))
 # define V8_HAS_ATTRIBUTE_NOINLINE (V8_GNUC_PREREQ(3, 4, 0))
+# define V8_HAS_ATTRIBUTE_NORETURN (V8_GNUC_PREREQ(2, 5, 0))
 # define V8_HAS_ATTRIBUTE_UNUSED (V8_GNUC_PREREQ(2, 95, 0))
 # define V8_HAS_ATTRIBUTE_VISIBILITY (V8_GNUC_PREREQ(4, 3, 0))
 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \
@@ -285,6 +289,7 @@
 # define V8_HAS_DECLSPEC_DEPRECATED 1
 # define V8_HAS_DECLSPEC_NOINLINE 1
 # define V8_HAS_DECLSPEC_SELECTANY 1
+# define V8_HAS_DECLSPEC_NORETURN 1
 
 # define V8_HAS___FORCEINLINE 1
 
@@ -319,6 +324,18 @@
 #endif
 
 
+// A macro used to tell the compiler that a particular function never returns.
+// Use like:
+//   V8_NORETURN void MyAbort() { abort(); }
+#if V8_HAS_ATTRIBUTE_NORETURN
+# define V8_NORETURN __attribute__((noreturn))
+#elif HAS_DECLSPEC_NORETURN
+# define V8_NORETURN __declspec(noreturn)
+#else
+# define V8_NORETURN /* NOT SUPPORTED */
+#endif
+
+
 // A macro (V8_DEPRECATED) to mark classes or functions as deprecated.
 #if defined(V8_DEPRECATION_WARNINGS) && V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE
 #define V8_DEPRECATED(message, declarator) \

src/arguments.h

@@ -29,10 +29,13 @@ namespace internal {
 class Arguments BASE_EMBEDDED {
  public:
   Arguments(int length, Object** arguments)
-      : length_(length), arguments_(arguments) { }
+      : length_(length), arguments_(arguments) {
+    DCHECK_GE(length_, 0);
+  }
 
   Object*& operator[] (int index) {
-    DCHECK(0 <= index && index < length_);
+    DCHECK_GE(index, 0);
+    DCHECK_LT(static_cast<uint32_t>(index), static_cast<uint32_t>(length_));
     return *(reinterpret_cast<Object**>(reinterpret_cast<intptr_t>(arguments_) -
                                         index * kPointerSize));
   }

src/base/logging.h

@@ -11,7 +11,8 @@
 
 #include "src/base/build_config.h"
 
-extern "C" void V8_Fatal(const char* file, int line, const char* format, ...);
+extern "C" V8_NORETURN void V8_Fatal(const char* file, int line,
+                                     const char* format, ...);
 
 
 // The FATAL, UNREACHABLE and UNIMPLEMENTED macros are useful during

src/base/platform/platform.h

@@ -194,7 +194,7 @@ class OS {
   static void Sleep(TimeDelta interval);
 
   // Abort the current process.
-  static void Abort();
+  V8_NORETURN static void Abort();
 
   // Debug break.
   static void DebugBreak();

src/heap/spaces-inl.h

@@ -446,7 +446,7 @@ AllocationResult NewSpace::AllocateRawAligned(int size_in_bytes,
 
 AllocationResult NewSpace::AllocateRawUnaligned(int size_in_bytes) {
   Address top = allocation_info_.top();
-  if (allocation_info_.limit() - top < size_in_bytes) {
+  if (allocation_info_.limit() < top + size_in_bytes) {
     // See if we can create room.
     if (!EnsureAllocation(size_in_bytes, kWordAligned)) {
       return AllocationResult::Retry();

test/cctest/interpreter/test-bytecode-generator.cc

@@ -157,6 +157,7 @@ static void CheckBytecodeArrayEqual(struct ExpectedSnippet<T> expected,
       switch (Bytecodes::SizeOfOperand(operand_type)) {
         case OperandSize::kNone:
           UNREACHABLE();
+          return;
         case OperandSize::kByte:
           expected_operand =
               static_cast<uint32_t>(expected.bytecode[operand_index]);
@@ -165,6 +166,9 @@ static void CheckBytecodeArrayEqual(struct ExpectedSnippet<T> expected,
           expected_operand = Bytecodes::ShortOperandFromBytes(
               &expected.bytecode[operand_index]);
           break;
+        default:
+          UNREACHABLE();
+          return;
       }
       if (raw_operand != expected_operand) {
         std::ostringstream stream;

test/cctest/test-assembler-arm.cc

@@ -337,8 +337,8 @@ TEST(4) {
     t.y = 9.0;
     Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
     USE(dummy);
-    CHECK_EQ(4.5f, t.y);
     CHECK_EQ(9.0f, t.x);
+    CHECK_EQ(4.5f, t.y);
     CHECK_EQ(-123.456, t.n);
     CHECK_EQ(2718.2818, t.m);
     CHECK_EQ(2, t.i);

test/cctest/test-atomicops.cc

@@ -157,21 +157,11 @@ static void TestAtomicExchange() {
 
 template <class AtomicType>
 static void TestAtomicIncrementBounds() {
-  // Test at rollover boundary between int_max and int_min.
-  AtomicType test_val =
-      static_cast<AtomicType>(1) << (NUM_BITS(AtomicType) - 1);
-  AtomicType value = -1 ^ test_val;
-  AtomicType new_value = NoBarrier_AtomicIncrement(&value, 1);
-  CHECK_EQU(test_val, value);
-  CHECK_EQU(value, new_value);
-
-  NoBarrier_AtomicIncrement(&value, -1);
-  CHECK_EQU(-1 ^ test_val, value);
-
   // Test at 32-bit boundary for 64-bit atomic type.
-  test_val = static_cast<AtomicType>(1) << (NUM_BITS(AtomicType) / 2);
+  AtomicType test_val = static_cast<AtomicType>(1)
-  value = test_val - 1;
+                        << (NUM_BITS(AtomicType) / 2);
-  new_value = NoBarrier_AtomicIncrement(&value, 1);
+  AtomicType value = test_val - 1;
+  AtomicType new_value = NoBarrier_AtomicIncrement(&value, 1);
   CHECK_EQU(test_val, value);
   CHECK_EQU(value, new_value);