MIPS: Change generated code for substring not to bail out to runtime system.

src/mips/code-stubs-mips.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 6008 matching lines @@
   __ jmp(&return_v0);
 
   if (FLAG_string_slices) {
     __ bind(&create_slice);
     // v0: original string
     // a1: instance type
     // a2: length
     // a3: from index (untagged smi)
     // t2 (a.k.a. to): to (smi)
     // t3 (a.k.a. from): from offset (smi)
-    Label allocate_slice, sliced_string, seq_string;
-    STATIC_ASSERT(kSeqStringTag == 0);
-    __ And(t4, a1, Operand(kStringRepresentationMask));
-    __ Branch(&seq_string, eq, t4, Operand(zero_reg));
+    Label allocate_slice, sliced_string, seq_or_external_string;
+    // If the string is not indirect, it can only be sequential or external.
     STATIC_ASSERT(kIsIndirectStringMask == (kSlicedStringTag & kConsStringTag));
     STATIC_ASSERT(kIsIndirectStringMask != 0);
     __ And(t4, a1, Operand(kIsIndirectStringMask));
     // External string.  Jump to runtime.
-    __ Branch(&sub_string_runtime, eq, t4, Operand(zero_reg));
+    __ Branch(&seq_or_external_string, eq, t4, Operand(zero_reg));
 
     __ And(t4, a1, Operand(kSlicedNotConsMask));
     __ Branch(&sliced_string, ne, t4, Operand(zero_reg));
     // Cons string.  Check whether it is flat, then fetch first part.
     __ lw(t1, FieldMemOperand(v0, ConsString::kSecondOffset));
     __ LoadRoot(t5, Heap::kEmptyStringRootIndex);
     __ Branch(&sub_string_runtime, ne, t1, Operand(t5));
     __ lw(t1, FieldMemOperand(v0, ConsString::kFirstOffset));
     __ jmp(&allocate_slice);
 
     __ bind(&sliced_string);
     // Sliced string.  Fetch parent and correct start index by offset.
     __ lw(t1, FieldMemOperand(v0, SlicedString::kOffsetOffset));
     __ addu(t3, t3, t1);
     __ lw(t1, FieldMemOperand(v0, SlicedString::kParentOffset));
     __ jmp(&allocate_slice);
 
-    __ bind(&seq_string);
-    // Sequential string.  Just move string to the right register.
+    __ bind(&seq_or_external_string);
+    // Sequential or external string.  Just move string to the correct register.
     __ mov(t1, v0);
 
     __ bind(&allocate_slice);
     // a1: instance type of original string
     // a2: length
     // t1: underlying subject string
     // t3 (a.k.a. from): from offset (smi)
     // Allocate new sliced string.  At this point we do not reload the instance
     // type including the string encoding because we simply rely on the info
     // provided by the original string.  It does not matter if the original
@@ skipping 1394 matching lines @@
                                  &slow_elements);
   __ Ret();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS