Revert of Internalize strings in-place

src/s390/codegen-s390.cc

 // Copyright 2015 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/s390/codegen-s390.h"
 
 #if V8_TARGET_ARCH_S390
 
 #include <memory>
 
@@ skipping 52 matching lines @@
 
 // -------------------------------------------------------------------------
 // Code generators
 
 #define __ ACCESS_MASM(masm)
 
 // assume ip can be used as a scratch register below
 void StringCharLoadGenerator::Generate(MacroAssembler* masm, Register string,
                                        Register index, Register result,
                                        Label* call_runtime) {
-  Label indirect_string_loaded;
-  __ bind(&indirect_string_loaded);
-
   // Fetch the instance type of the receiver into result register.
   __ LoadP(result, FieldMemOperand(string, HeapObject::kMapOffset));
   __ LoadlB(result, FieldMemOperand(result, Map::kInstanceTypeOffset));
 
   // We need special handling for indirect strings.
   Label check_sequential;
   __ mov(r0, Operand(kIsIndirectStringMask));
   __ AndP(r0, result);
   __ beq(&check_sequential, Label::kNear /*, cr0*/);
 
   // Dispatch on the indirect string shape: slice or cons.
-  Label cons_string, thin_string;
-  __ LoadRR(ip, result);
-  __ nilf(ip, Operand(kStringRepresentationMask));
-  __ CmpP(ip, Operand(kConsStringTag));
-  __ beq(&cons_string);
-  __ CmpP(ip, Operand(kThinStringTag));
-  __ beq(&thin_string);
+  Label cons_string;
+  __ mov(ip, Operand(kSlicedNotConsMask));
+  __ LoadRR(r0, result);
+  __ AndP(r0, ip /*, SetRC*/);  // Should be okay to remove RC
+  __ beq(&cons_string, Label::kNear /*, cr0*/);
 
   // Handle slices.
+  Label indirect_string_loaded;
   __ LoadP(result, FieldMemOperand(string, SlicedString::kOffsetOffset));
   __ LoadP(string, FieldMemOperand(string, SlicedString::kParentOffset));
   __ SmiUntag(ip, result);
   __ AddP(index, ip);
-  __ b(&indirect_string_loaded);
-
-  // Handle thin strings.
-  __ bind(&thin_string);
-  __ LoadP(string, FieldMemOperand(string, ThinString::kActualOffset));
-  __ b(&indirect_string_loaded);
+  __ b(&indirect_string_loaded, Label::kNear);
 
   // Handle cons strings.
   // Check whether the right hand side is the empty string (i.e. if
   // this is really a flat string in a cons string). If that is not
   // the case we would rather go to the runtime system now to flatten
   // the string.
   __ bind(&cons_string);
   __ LoadP(result, FieldMemOperand(string, ConsString::kSecondOffset));
   __ CompareRoot(result, Heap::kempty_stringRootIndex);
   __ bne(call_runtime);
   // Get the first of the two strings and load its instance type.
   __ LoadP(string, FieldMemOperand(string, ConsString::kFirstOffset));
-  __ b(&indirect_string_loaded);
+
+  __ bind(&indirect_string_loaded);
+  __ LoadP(result, FieldMemOperand(string, HeapObject::kMapOffset));
+  __ LoadlB(result, FieldMemOperand(result, Map::kInstanceTypeOffset));
 
   // Distinguish sequential and external strings. Only these two string
   // representations can reach here (slices and flat cons strings have been
   // reduced to the underlying sequential or external string).
   Label external_string, check_encoding;
   __ bind(&check_sequential);
   STATIC_ASSERT(kSeqStringTag == 0);
   __ mov(r0, Operand(kStringRepresentationMask));
   __ AndP(r0, result);
   __ bne(&external_string, Label::kNear);
@@ skipping 102 matching lines @@
       //       (kNoCodeAgeSequenceLength - kCodeAgingSequenceLength) bytes.
       patcher.masm()->nop();  // 2-byte nops().
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_S390