S390: Initial Impl of Crankshaft features

src/crankshaft/s390/lithium-codegen-s390.h

 // Copyright 2014 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.
 
-#ifndef V8_CRANKSHAFT_PPC_LITHIUM_CODEGEN_PPC_H_
-#define V8_CRANKSHAFT_PPC_LITHIUM_CODEGEN_PPC_H_
+#ifndef V8_CRANKSHAFT_S390_LITHIUM_CODEGEN_S390_H_
+#define V8_CRANKSHAFT_S390_LITHIUM_CODEGEN_S390_H_
 
 #include "src/ast/scopes.h"
 #include "src/crankshaft/lithium-codegen.h"
-#include "src/crankshaft/ppc/lithium-gap-resolver-ppc.h"
-#include "src/crankshaft/ppc/lithium-ppc.h"
+#include "src/crankshaft/s390/lithium-gap-resolver-s390.h"
+#include "src/crankshaft/s390/lithium-s390.h"
 #include "src/deoptimizer.h"
 #include "src/safepoint-table.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class LDeferredCode;
 class SafepointGenerator;
 
 class LCodeGen : public LCodeGenBase {
  public:
   LCodeGen(LChunk* chunk, MacroAssembler* assembler, CompilationInfo* info)
       : LCodeGenBase(chunk, assembler, info),
         jump_table_(4, info->zone()),
         scope_(info->scope()),
         deferred_(8, info->zone()),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }
 
-
   int LookupDestination(int block_id) const {
     return chunk()->LookupDestination(block_id);
   }
 
   bool IsNextEmittedBlock(int block_id) const {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }
 
   bool NeedsEagerFrame() const {
     return HasAllocatedStackSlots() || info()->is_non_deferred_calling() ||
@@ skipping 168 matching lines @@
                         int* object_index_pointer,
                         int* dematerialized_index_pointer);
 
   Register ToRegister(int index) const;
   DoubleRegister ToDoubleRegister(int index) const;
 
   MemOperand BuildSeqStringOperand(Register string, LOperand* index,
                                    String::Encoding encoding);
 
   void EmitMathAbs(LMathAbs* instr);
-#if V8_TARGET_ARCH_PPC64
+#if V8_TARGET_ARCH_S390X
   void EmitInteger32MathAbs(LMathAbs* instr);
 #endif
 
   // Support for recording safepoint and position information.
   void RecordSafepoint(LPointerMap* pointers, Safepoint::Kind kind,
                        int arguments, Safepoint::DeoptMode mode);
   void RecordSafepoint(LPointerMap* pointers, Safepoint::DeoptMode mode);
   void RecordSafepoint(Safepoint::DeoptMode mode);
   void RecordSafepointWithRegisters(LPointerMap* pointers, int arguments,
                                     Safepoint::DeoptMode mode);
 
   void RecordAndWritePosition(int position) override;
 
   static Condition TokenToCondition(Token::Value op);
   void EmitGoto(int block);
 
   // EmitBranch expects to be the last instruction of a block.
   template <class InstrType>
-  void EmitBranch(InstrType instr, Condition condition, CRegister cr = cr7);
+  void EmitBranch(InstrType instr, Condition condition);
   template <class InstrType>
-  void EmitTrueBranch(InstrType instr, Condition condition, CRegister cr = cr7);
+  void EmitTrueBranch(InstrType instr, Condition condition);
   template <class InstrType>
-  void EmitFalseBranch(InstrType instr, Condition condition,
-                       CRegister cr = cr7);
+  void EmitFalseBranch(InstrType instr, Condition condition);
   void EmitNumberUntagD(LNumberUntagD* instr, Register input,
                         DoubleRegister result, NumberUntagDMode mode);
 
   // Emits optimized code for typeof x == "y".  Modifies input register.
   // Returns the condition on which a final split to
   // true and false label should be made, to optimize fallthrough.
   Condition EmitTypeofIs(Label* true_label, Label* false_label, Register input,
                          Handle<String> type_name);
 
   // Emits optimized code for %_IsString(x).  Preserves input register.
@@ skipping 55 matching lines @@
    private:
     LCodeGen* codegen_;
   };
 
   friend class LDeferredCode;
   friend class LEnvironment;
   friend class SafepointGenerator;
   DISALLOW_COPY_AND_ASSIGN(LCodeGen);
 };
 
-
 class LDeferredCode : public ZoneObject {
  public:
   explicit LDeferredCode(LCodeGen* codegen)
       : codegen_(codegen),
         external_exit_(NULL),
         instruction_index_(codegen->current_instruction_) {
     codegen->AddDeferredCode(this);
   }
 
   virtual ~LDeferredCode() {}
@@ skipping 12 matching lines @@
  private:
   LCodeGen* codegen_;
   Label entry_;
   Label exit_;
   Label* external_exit_;
   int instruction_index_;
 };
 }  // namespace internal
 }  // namespace v8
 
-#endif  // V8_CRANKSHAFT_PPC_LITHIUM_CODEGEN_PPC_H_
+#endif  // V8_CRANKSHAFT_S390_LITHIUM_CODEGEN_S390_H_