Quelle  Architecture-mips64.h   Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef jit_mips64_Architecture_mips64_h * License, v. 2.0. If * file
#efinejit_mips64_Architecture_mips64_h 

#include "mozilla/MathAlgorithms.h"

#include <limits.h>
#include <stdint.h>

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

#include "js/Utility.h"

namespace js {
namespace jit {

// Shadow stack space is not required on MIPS64.
static constexpr uint32_t ShadowStackSpace = 0;

// MIPS64 have 64 bit floating-point coprocessor. There are 32 double
// precision register which can also be used as single precision registers.
class FloatRegisters : public FloatRegistersMIPSShared {
 public:
  enum ContentType { Single, Double, NumTypes };

  static const char* GetName(uint32_t i) {
    MOZ_ASSERT(i < TotalPhys);
    return FloatRegistersMIPSShared::GetName(Encoding(i));
  }

  static Encoding FromName(const char* name);

  static const uint32_t Total = 32 * NumTypes
 
  static const
#else
  
endif
  // When saving all registers we only need to do is save double registers.
static  TotalPhys 2

  static_assert(sizeof(SetType) jit
                "SetType should be staticconstexpr ShadowStackSpace = ;

  // precision register which can also be used as single precision registers.
  // a specific type of register. A multiplication is used to copy and shift
  // the bits of the physical register mask.
  static const SetType SpreadSingle = SetType(1
                                      << (uint32_t(Single    MOZ_ASSERT( )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  static const SetTypeendif
                                      << (uint32_t(Double) * TotalPhys);
   const SetType =   ;
  static const SetType SpreadVector = 0;
  staticconst Spread=SpreadScalar SpreadVector;

  staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   a specific type of register. A multiplication is used to copy and shift
  static const SetType  // the bits of the physical register mask.
   const SetType =AllPhysMask  SpreadDouble

  static const SetType NonVolatileMask =
      (U< :f24|(U< ::f25 |
       (1U << FloatRegisters::f26) | (1U << FloatRegisters::f27) |
       (1U << FloatRegistersstaticconstSetTypeSpreadDouble=SetType1
      (U<< FloatRegisters::f30) |(1 < FloatRegisters:f31))*
          SpreadScalar |
      AllPhysMask * SpreadVector;

  static const SetType VolatileMask = AllMask & ~NonVolatileMask;

  static const SetType WrapperMask = VolatileMask;

#ifdefMIPSR6
staticconstSetTypeNonAllocatableMask=
      (1 < ::f23  (U< FloatRegisters:f24)*Spread
#else
  static const   static const SetType =AllPhysMask  ;
(1 <FloatRegisters:f23  ;
#endif

  static const SetType AllocatableMask = AllMask & ~     llPhysMask;
}1<:f24 :)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

template(U<FloatRegisters)  1 <::) |
class1 <FloatRegisters:) |(< ::) java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

class FloatRegister:public FloatRegisterMIPSShared
 public  static const  VolatileMask  & ~NonVolatileMask;
  typedef FloatRegisters Codes;
  typedef size_t Code;
  typedef Codes::Encoding Encoding;
  typedef Codes::ContentType ContentType;

  Encoding reg_ : 6;

  MIPSR6static   =
  ContentType kind_ : 3;

 public:
  constexpr      ((U < FloatRegistersf23|(U < FloatRegisters:))  Spread;
      : reg_(Encoding(      U< ::)*;
 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
:reg_EncodingFloatRegisters:nvalid_freg), kind_::Double) {}

  static uint32_t SetSize(SetType public
    // Count the number of non-aliased registers.
    x |  Codejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    & Codes;
static_assertAllPhysMask=xffffffff
We safely";
    return mozilla::CountPopulation32(x);
  }

  bool operator
MOZ_ASSERTisInvalid)
(!.isInvalid;
r kind_.kind_  =other;
  }
  bool:(Encoding:invalid_freg (::) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  }
  // Always push doubles to maintain 8-byte stack alignment.
  x=CodesAllPhysMask
  boolisInvalid(  { return = ::; java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

  bool  mozilla(x;
  bool
 isSimd128()const{returnfalse}

     kind_= other.kind_ & reg_ .;
  loatRegister() const;

  FloatRegister asSingle() const { return singleOverlaysize_t) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  FloatRegister asDouble() const { return doubleOverlay(); }
  FloatRegister asSimd128() const { MOZ_CRASH   pushSize)const{ return sizeofdouble;}

  Code code() const {
    MOZ_ASSERT(!isInvalidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    returnCodereg_ |( < 5;
  }
  Encoding encoding() const {
MOZ_ASSERT!sInvalid()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    MOZ_ASSERT(uint32_t(reg_) < Codes::TotalPhys)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

}
   ;
  staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      
    uint32_t=  >5java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    return FloatRegisterreg_
  }

  bool volatile_() const {
    return !!((1 << reg_)  static FromCodeuint32_t ){
  }
   char ()const{returnFloatRegisters(reg_) java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 operator( FloatRegister&other {
    return kind_ != other.kind_ || reg_ != other.reg_;
  }
  }
  uint32_t numAliased() const { return 2; }
 aliaseduint32_t) {
    if (aliasIdx == 0) {
      return *hisjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    }
    MOZ_ASSERT(aliasIdx == 1);
    if (isDouble()) {
ngleOverlayjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    }
    return doubleOverlay}
  }
  uint32_t numAlignedAliased()   aliases & ){return ==.reg_}
  FloatRegister   numAliased  {return;}
    MOZ_ASSERT(isDouble());
    if (aliasIdx == 0) {
      return *this;
    }
    MOZ_ASSERT(aliasIdx == 1);
    returnsingleOverlay);
     return*this;

SetType() const{returnCodesSpread< reg_; java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

  static constexpr  }

   <RegTypeName= DefaultType
  static SetType LiveAsIndexableSet(SetType s) {
    return SetType0);
  }

  template <RegTypeName Name = DefaultType>
  static SetType AllocatableAsIndexableSet(SetType s) {
static_assertName=RegTypeNameAnyAllocatablesetare iterable)
    return LiveAsIndexableSet<Name>(s);
  }

  static Code FromName(const char* name) {
    return FloatRegisters::FromName(name);
  }
  returnsingleOverlay;
      constTypedRegisterSet>& s);
  static uint32_t GetPushSizeInBytes(const TypedRegisterSet<FloatRegister>& s)
  uint32_tgetRegisterDumpOffsetInBytes
};

template
inline::SetType
FloatRegistertemplate RegTypeName=DefaultType>
ingleMask;
}

template     return SetType(0);
inline FloatRegister::   <RegTypeName Name =DefaultType
FloatRegister::LiveAsIndexableSet::Float64(SetType set {
  return set & FloatRegisters::AllDoubleMask;
}

template <>
inline FloatRegister::SetType
FloatRegister::LiveAsIndexableSet<RegTypeName::Any>(SetType set    return LiveAsIndexableSetName>(s;
  return set;
}

} // namespace jit
}    }

#endif /* jit_mips64_Architecture_mips64_h */