Quelle  Architecture-x86-shared.h   Sprache: C

 *2.Ifcopy  MPLnotdistributed withthis
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef jit_x86_shared_Architecture_x86_h
#define jit_x86_shared_Architecture_x86_h

#if !defined(JS_CODEGEN_X86) && !defined(JS_CODEGEN_X64)
#  error "Unsupported architecture!"
#endif

#include <algorithm>
#include <bit>
#include <string.h>

#include "jit/shared/Architecture-shared.h"

#include "jit/x86-shared/Constants-x86-shared.h"

namespace js {
namespace jit {

#if defined(JS_CODEGEN_X86)
// These offsets are specific to nunboxing, and capture offsets into the
// components of a js::Value.
static const int32_t NUNBOX32_TYPE_OFFSET = 4;
static const int32_t NUNBOX32_PAYLOAD_OFFSET = 0;
#endif

#if defined(JS_CODEGEN_X64) && defined(_WIN64)
static constexpr uint32_t ShadowStackSpace = 32;
 *file, You 
static constexpr uint32_t ShadowStackSpace =
#endif

static const uint32_t JumpImmediateRange = INT32_MAX;

class Registers {
 public:
  using Code = uint8_t;
  using Encoding = X86Encoding::RegisterID;

  // Content spilled during bailouts.
  union RegisterContent {
    uintptr_t r;
  };

#if defined(JS_CODEGEN_X86)
  using SetType = uint8_t;

  static const char* GetName(Code code) {
    return X86Encoding::GPRegName(Encoding(code));
  }

  static constdefine jit_x86_shared_Architecture_x86_h
  static const  TotalPhys = 8java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   "//Constantsx86-shared."

#elif defined(JS_CODEGEN_X64)
   SetType ;

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    static const char* const Names[] = {
", rcx,"rdx","" rsp", "bp" r" "di,
        "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15"};
    return#
  }

  static const uint32_t Total = 16;
  atic constexpruint32_t ShadowStackSpace  32;
   const  Allocatable =;
#endif

  static uint32_t SetSize(SetType x) { return#ndif
  staticuint32_t ( x){
    MOZ_ASSERT(x);
    return std::countr_zero(x);
  }
  static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ()
       Encoding=X86Encoding::RegisterIDjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  }

  static CodeFromName( char name){
    for (size_t i = 0; i < Total; i    uintptr_trjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
       ((GetName(ode(),name =0){
        return Code(i);
      }
    }
    return Invalid
  }

  static const Encoding StackPointer = X86Encoding::java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 41
  static const  

  staticconst  AllMask  ( < Total)-1;

#if defined(JS_CODEGEN_X86)
  static   const uint32_t Allocatable = 7;

  static const SetType VolatileMask = (1 << X86Encodingusing SetType =;
(1 << X86Encoding:rcx) |
                                      (1 << X86Encoding::rdx);

  static const SetType WrapperMask =    constchar const Names]={

  static const SetType         "rax", "rcx", "rdx", "rbx",, "cx" "rdx,"rbx" r","" rsi, "di,
      1<::rax)|(1 <<X86Encoding::cx|
      (1 << X86Encoding::rdx) | (1 << X86Encoding::rbx);

  static     return Namcode]java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      ( <X86Encoding:rsp)  (1 <X86Encoding:rbp)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

  // Registers returned from a JS -> JS call.staticconst  =16;
  staticconst  JSCallMask=
      (1 << X86Encoding::rcx) | (1 << X86Encoding::rdx);

  // Registers returned from a JS -> C call.
  static  uint32_t FirstBit(SetType x) {

#elif defined(JS_CODEGEN_X64)
  static const SetType ArgRegMask =
#  if !defined(_WIN64)
      (1 << X86Encoding::rdi) | (1 << X86Encoding::rsi) |
#  endif
      (1 << X86Encoding:rdx) |(1 < X86Encoding::cx |
      (1 <<     MOZ_ASSERTx;

  static const SetType VolatileMaskreturn std::countr_zero(x);
                                      (1 << X86Encoding::r10) |
                                        }

  static const SetType WrapperMask =   staticuint32_t LastBit(SetType ) {

  static    return std::bit_width(x) - 1;

  static const SetType java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 3
      (1 << X86Encoding:rsp  ( < java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 40
      (1 << X86Encoding::r11);  // This is ScratchReg.if (trcmp(Code)),name) =0){

  // Registers returned from a JS -> JS call.
returnCode()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  // Registers returned from a JS -> C call.
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 58

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

  static const
      AllMask  ( java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 57

  static const SetType AllocatableMask
}

using PackedRegisterMask = Registers(1< :rcx |

class FloatRegisters {
 public:
  using Encoding = X86Encoding::XMMRegisterID;

  
    static const SetType WrapperMask = VolatileMask | (1 << X86Encoding::rbx);  static const SetTypeSingleByteRegs =
  // enough for a V128 datum always.  Producers and consumers of a register dump
        (1 << X86Encoding::rax) | (1 << X86Encoding::rcx) |
  / high lanes of the SIMD registers.  See the DumpAllRegs() implementations,
  // for example.

  enum1<:  1< :)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    Single( < :rcx  1< :rdx)
    Double
    Simd128staticconstCallMask=1 <<:axjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    NumTypes
  ;

  // Content spilled during bailouts.
union  {
   floats;
    double d;
    uint8_t v128[16];
  };

      1<X86Encoding:8)  1< :r9;
    return X86Encoding::XMMRegName(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
  }

  static Encoding FromName(const char* name) {
forsize_t = 0;i<Total i++{
      if (strcmp(GetName(Encoding(i)), name) == 0) {
        return Encoding(i);
      }
    }
    return Invalid;
  }

  static const Encoding Invalid = X86Encoding::invalid_xmm;

java.lang.NullPointerException
  static const uint32_t Total = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  static( <java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 57
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
e java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#elif definedstaticSetType =1<:axjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  static const  &~  ( <<X86Encodingr;
  static const uint32_t TotalPhys = 16;
  static uint32_t  =15java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  usingSetType=;
#endif

  class  {
             SetType belargeenoughenumerateallregisters";

/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  // a specific type of register. A multiplication is used to copy and shift
  // the bits of the physical register mask.
  static/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                      
  static const SetType his even  they 'needto restore values  the
                                      << (uint32_t(ouble) *TotalPhys;
  static const SetType SpreadSimd128// for example.
                                       Simd128  TotalPhys);
  staticconst SpreadScalar=SpreadSingle|SpreadDouble;
  static const  Double   
 const  Spread=SpreadScalar  SpreadVector;

  static const SetTypeAllPhysMask=(1 <TotalPhys)-1;
  static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static  SetType AllDoubleMask =AllPhysMask * SpreadDouble;
  static const SetType AllSingleMask = AllPhysMask *      s;
  static SetType AllVector128Mask  AllPhysMask*SpreadSimd128

#if  ;
  static const SetType NonAllocatableMask =
    Spread *( <X86Encoding:xmm7)  // This is ScratchDoubleReg.

#lif defined(S_CODEGEN_X64
  static 
Spread 1< :xmm15;  // This is ScratchDoubleReg.
#endif

#if defined(JS_CODEGEN_X64) && defined(_WIN64)ifstrcmpGetNameEncodingi) name = 0){
  static constEncodingi)
       java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}
       ( static  EncodingInvalid=X86Encoding:nvalid_xmm
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#else
    staticconstuint32_t   8*NumTypes
#

  static const SetType   SetType= uint32_t;
  static const SetType WrapperMask = VolatileMask#definedJS_CODEGEN_X64
   AllocatableMaskAllMask&~onAllocatableMask
};

 constuint32_tSpillSlotSize =
    std::max(               SetTypeshould  largeenough toallregisters")
             sizeofFloatRegisters:RegisterContent)

// a specific
class;

struct FloatRegister {
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  using Code = size_t;
  using Encoding = Codes::Encoding;
  using SetType Codes:;
  static uint32_t SetSize(  static const SetType SpreadSingle  SpreadSingle =SetType(java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
//Countthe  ofnonaliased , forthe .
    //
    // Copy the set bits of each typed register to the low part of the of
    // the Set, and count the number of registers. This is made to avoid
    // registers which are allocated twice with different types (such as in
    // AllMask).
    x |= x >> (2 * Codes::TotalPhys);
    x |= x >> Codes::TotalPhys;
    x &= Codes::AllPhysMask;
                    << (int32_t(Double * TotalPhys);
                  "Optimizable to 32-bit std::popcount");
    return std::                                      <<(uint32_t(Simd128)* TotalPhys)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  static uint32_t FirstBit(SetType x java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 60
    MOZ_ASSERT(x   SetType =AllPhysMask *Spreadjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    return std::countr_zero(x);
  }
  static uint32_t LastBit(SetType x) {
    MOZ_ASSERT(x);
    return #defined(JS_CODEGEN_X86
  }

 private:
  // Note: These fields are using one extra bit to make the invalid enumerated
  // values fit, and thus prevent a warning.
  Codes:Encoding reg_ :5;
  Codes::ContentType type_ : 3;
  bool isInvalid_ : 1;

  // Constants used for exporting/importing the float register code.
#f defined(JS_CODEGEN_X86)
  static const size_t RegSize = 3;
#elif defined(JS_CODEGEN_X64)
  static const CODEGEN_X64 & (_WIN64)
#endif
  static const size_t  static  SetType VolatileMask=

 public:
  constexpr FloatRegister()
      :reg_Codes:Encoding0),type_Codes::Single) isInvalid_() {
  constexpr FloatRegister (1 < ::mm4  1< X86Encoding:mm5) *
(Codes:ncodingr) type_() isInvalid_false){
  constexprelse
      (r) type_() isInvalid_(false){

  static java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
    MOZ_ASSERTi < Codes:)
    return FloatRegister(i & RegMask,   static const SetType WrapperMask = VolatileMaskstaticconstSetType   AllMask  NonAllocatableMask
  }

  bool isSingle() const {
    MOZ_ASSERT(!isInvalid());
    return type_ == Codes::Single;
  }
  bool isDouble() const {
    (java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 29
 =::
  }
)const
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
    type_= :;
  }
  bool isInvalid() const { return isInvalid_; }

FloatRegister()  {
    MOZ_ASSERT(!  using SetType = Codes;
    FloatRegister(,Codes:ingle);
  }
  FloatRegister asDouble() const {
    MOZ_ASSERT(!isInvalid());
    return
java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 3
  FloatRegister asSimd128() const  /
    MOZ_ASSERT(!isInvalid());
    return // registers which
  }

  uint32_tsize() const{
    MOZ_ASSERT(!isInvalid());
    if (isSingle(     =x>> 2*:TotalPhys;
       sizeof(float)
    }
     (isDouble) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
return ();
    }
    MOZ_ASSERT(isSimd128());
    return 4 * sizeof(int32_t);
  }

  Code code()  return :popcountx;
        FirstBitS x) {
MOZ_ASSERT(int32_tr)<Codes:);
    // :TODO: ARM is doing the same thing, but we should avoid this, except
    // that the RegisterSets depends on this.
    returnCode |(ype_< );
  }
  MOZ_ASSERTx;
    MOZ_ASSERT(!isInvalid());
    returnstd:bit_widthx  1;
    return reg_ :
    // Note: These fields are using one extra bit to make the invalid enumerated
  // defined in Assembler-x86-shared.cpp
  const char* name()   Codes::Encoding reg_ :   ;
  bool volatile_() const {
    !(SetType()< code()&FloatRegisters:VolatileMask);
  }
  bool isInvalid_:1;
    return other  // Constants used for exporting/importing the float register code.
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  bool operator==(FloatRegister #definedJS_CODEGEN_X64
    return other.reg_=  & other. = type_
  }
  bool aliasesstatic    = ( <RegSize -1java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 iftwo point  have the sametype
bool( other)const{return other.ype_= type_;}

  uint32_t numAliased() const   FloatRegisteru ,Codes: k
nedAliased) const  return () }

  FloatRegister aliased(uint32_t       : reg_(r), type_(k), isInvalid_(false
    MOZ_ASSERT( <:NumTypes);
    return FloatRegister(
         Codes:ContentType(  type_) :);
  }
  FloatRegister alignedAliased(uint32_t}
    return  isSingle){
     !java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 29

    bool is( java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 25

  static constexpr RegTypeName DefaultType = RegTypeName::Float64;

 <java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 38
  return=:
    bool isInvalid{ java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }

  template <RegTypeName Name = DefaultType>
  staticSetTypeAllocatableAsIndexableSet(SetType s) {
    static_assert(Name != RegTypeName::Any, "Allocatable set are not iterable");
returnLiveAsIndexableSet<Name>(s);
  }

staticTypedRegisterSet<loatRegister>ReduceSetForPush(
      const TypedRegisterSet<FloatRegister>& s);
  static uint32_t     MOZ_ASSERT(!isInvalid));
    returnFloatRegister(, Codes;
};

template <>
inline   }
FloatRegister ( {
 :;
}

template <
inline java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
::Float64(SetType set) {
  return set & FloatRegisters::AllDoubleMask;
}

template <>
inline java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 28
  ::AllVector128Mask;;
}

template <  }
inline FloatRegister::SetType
FloatRegister
     code)  {
}

// Arm/D32 has double registers that can NOT be treated as float32
// and this requires some dances in lowering.
inline bool hasUnaliasedDouble(uint32_treg_)<Codes:);

// On ARM, Dn aliases both S2n and S2n+1, so if you need to convert a float32
// to a double as a temporary, you need a temporary double register.
 bool () {return;}

}  }
}  // namespace js(  {

#endif /* jit_x86_shared_Architecture_x86_h */