[arm64] Fix pre-shifted immediate generation involving csp.

src/arm64/macro-assembler-arm64.h

 // Copyright 2013 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_ARM64_MACRO_ASSEMBLER_ARM64_H_
 #define V8_ARM64_MACRO_ASSEMBLER_ARM64_H_
 
 #include <vector>
 
 #include "src/arm64/assembler-arm64.h"
@@ skipping 144 matching lines @@
 enum TargetAddressStorageMode {
   CAN_INLINE_TARGET_ADDRESS,
   NEVER_INLINE_TARGET_ADDRESS
 };
 enum UntagMode { kNotSpeculativeUntag, kSpeculativeUntag };
 enum ArrayHasHoles { kArrayCantHaveHoles, kArrayCanHaveHoles };
 enum CopyHint { kCopyUnknown, kCopyShort, kCopyLong };
 enum DiscardMoveMode { kDontDiscardForSameWReg, kDiscardForSameWReg };
 enum SeqStringSetCharCheckIndexType { kIndexIsSmi, kIndexIsInteger32 };
 
+// The macro assembler supports moving automatically pre-shifted immediates for
+// arithmetic and logical instructions, and then applying a post shift in the
+// instruction to undo the modification, in order to reduce the code emitted for
+// an operation. For example:
+//
+//  Add(x0, x0, 0x1f7de) => movz x16, 0xfbef; add x0, x0, x16, lsl #1.
+//
+// This optimisation can be only partially applied when the stack pointer is an
+// operand or destination, so this enumeration is used to control the shift.
+enum PreShiftImmMode {
+  kNoShift,          // Don't pre-shift.
+  kLimitShiftForSP,  // Limit pre-shift for add/sub extend use.
+  kAnyShift          // Allow any pre-shift.
+};
+
 class MacroAssembler : public Assembler {
  public:
   MacroAssembler(Isolate* isolate, byte* buffer, unsigned buffer_size,
                  CodeObjectRequired create_code_object);
 
   Isolate* isolate() const { return isolate_; }
 
   Handle<Object> CodeObject() {
     DCHECK(!code_object_.is_null());
     return code_object_;
@@ skipping 94 matching lines @@
   // Try to move an immediate into the destination register in a single
   // instruction. Returns true for success, and updates the contents of dst.
   // Returns false, otherwise.
   bool TryOneInstrMoveImmediate(const Register& dst, int64_t imm);
 
   // Move an immediate into register dst, and return an Operand object for use
   // with a subsequent instruction that accepts a shift. The value moved into
   // dst is not necessarily equal to imm; it may have had a shifting operation
   // applied to it that will be subsequently undone by the shift applied in the
   // Operand.
-  Operand MoveImmediateForShiftedOp(const Register& dst, int64_t imm);
+  Operand MoveImmediateForShiftedOp(const Register& dst, int64_t imm,
+                                    PreShiftImmMode mode);
 
   // Conditional macros.
   inline void Ccmp(const Register& rn,
                    const Operand& operand,
                    StatusFlags nzcv,
                    Condition cond);
   inline void Ccmn(const Register& rn,
                    const Operand& operand,
                    StatusFlags nzcv,
                    Condition cond);
@@ skipping 2407 matching lines @@
   class RegisterBits : public BitField<unsigned, 0, 5> {};
   class DeltaBits : public BitField<uint32_t, 5, 32-5> {};
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #define ACCESS_MASM(masm) masm->
 
 #endif  // V8_ARM64_MACRO_ASSEMBLER_ARM64_H_