The Tor Browser: js/src/jit/mips/LIR-mips.h@129ffea94266 (annotated)

js/src/jit/mips/LIR-mips.h@129ffea94266 (annotated)

js/src/jit/mips/LIR-mips.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * 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_mips_LIR_mips_h
 #define jit_mips_LIR_mips_h
 namespace js {
 namespace jit {
 class LBox : public LInstructionHelper<2, 1, 0>
 {
     MIRType type_;
   public:
     LIR_HEADER(Box);
     LBox(const LAllocation &in_payload, MIRType type)
       : type_(type)
     {
         setOperand(0, in_payload);
     }
     MIRType type() const {
         return type_;
     }
     const char *extraName() const {
         return StringFromMIRType(type_);
     }
 };
 class LBoxFloatingPoint : public LInstructionHelper<2, 1, 1>
 {
     MIRType type_;
   public:
     LIR_HEADER(BoxFloatingPoint);
     LBoxFloatingPoint(const LAllocation &in, const LDefinition &temp, MIRType type)
       : type_(type)
     {
         setOperand(0, in);
         setTemp(0, temp);
     }
     MIRType type() const {
         return type_;
     }
     const char *extraName() const {
         return StringFromMIRType(type_);
     }
 };
 class LUnbox : public LInstructionHelper<1, 2, 0>
 {
   public:
     LIR_HEADER(Unbox);
     MUnbox *mir() const {
         return mir_->toUnbox();
     }
     const LAllocation *payload() {
         return getOperand(0);
     }
     const LAllocation *type() {
         return getOperand(1);
     }
     const char *extraName() const {
         return StringFromMIRType(mir()->type());
     }
 };
 class LUnboxFloatingPoint : public LInstructionHelper<1, 2, 0>
 {
     MIRType type_;
   public:
     LIR_HEADER(UnboxFloatingPoint);
     static const size_t Input = 0;
     LUnboxFloatingPoint(MIRType type)
       : type_(type)
     { }
     MUnbox *mir() const {
         return mir_->toUnbox();
     }
     MIRType type() const {
         return type_;
     }
     const char *extraName() const {
         return StringFromMIRType(type_);
     }
 };
 // Convert a 32-bit unsigned integer to a double.
 class LAsmJSUInt32ToDouble : public LInstructionHelper<1, 1, 0>
 {
   public:
     LIR_HEADER(AsmJSUInt32ToDouble)
     LAsmJSUInt32ToDouble(const LAllocation &input) {
         setOperand(0, input);
     }
 };
 // Convert a 32-bit unsigned integer to a float32.
 class LAsmJSUInt32ToFloat32 : public LInstructionHelper<1, 1, 0>
 {
   public:
     LIR_HEADER(AsmJSUInt32ToFloat32)
     LAsmJSUInt32ToFloat32(const LAllocation &input) {
         setOperand(0, input);
     }
 };
 class LDivI : public LBinaryMath<1>
 {
   public:
     LIR_HEADER(DivI);
     LDivI(const LAllocation &lhs, const LAllocation &rhs,
           const LDefinition &temp) {
         setOperand(0, lhs);
         setOperand(1, rhs);
         setTemp(0, temp);
     }
     MDiv *mir() const {
         return mir_->toDiv();
     }
 };
 class LDivPowTwoI : public LInstructionHelper<1, 1, 1>
 {
     const int32_t shift_;
   public:
     LIR_HEADER(DivPowTwoI)
     LDivPowTwoI(const LAllocation &lhs, int32_t shift, const LDefinition &temp)
       : shift_(shift)
     {
         setOperand(0, lhs);
         setTemp(0, temp);
     }
     const LAllocation *numerator() {
         return getOperand(0);
     }
     int32_t shift() {
         return shift_;
     }
     MDiv *mir() const {
         return mir_->toDiv();
     }
 };
 class LModI : public LBinaryMath<1>
 {
   public:
     LIR_HEADER(ModI);
     LModI(const LAllocation &lhs, const LAllocation &rhs,
           const LDefinition &callTemp)
     {
         setOperand(0, lhs);
         setOperand(1, rhs);
         setTemp(0, callTemp);
     }
     const LDefinition *callTemp() {
         return getTemp(0);
     }
     MMod *mir() const {
         return mir_->toMod();
     }
 };
 class LModPowTwoI : public LInstructionHelper<1, 1, 0>
 {
     const int32_t shift_;
   public:
     LIR_HEADER(ModPowTwoI);
     int32_t shift()
     {
         return shift_;
     }
     LModPowTwoI(const LAllocation &lhs, int32_t shift)
       : shift_(shift)
     {
         setOperand(0, lhs);
     }
     MMod *mir() const {
         return mir_->toMod();
     }
 };
 class LModMaskI : public LInstructionHelper<1, 1, 1>
 {
     const int32_t shift_;
   public:
     LIR_HEADER(ModMaskI);
     LModMaskI(const LAllocation &lhs, const LDefinition &temp1, int32_t shift)
       : shift_(shift)
     {
         setOperand(0, lhs);
         setTemp(0, temp1);
     }
     int32_t shift() const {
         return shift_;
     }
     MMod *mir() const {
         return mir_->toMod();
     }
 };
 class LPowHalfD : public LInstructionHelper<1, 1, 0>
 {
   public:
     LIR_HEADER(PowHalfD);
     LPowHalfD(const LAllocation &input) {
         setOperand(0, input);
     }
     const LAllocation *input() {
         return getOperand(0);
     }
     const LDefinition *output() {
         return getDef(0);
     }
 };
 // Takes a tableswitch with an integer to decide
 class LTableSwitch : public LInstructionHelper<0, 1, 2>
 {
   public:
     LIR_HEADER(TableSwitch);
     LTableSwitch(const LAllocation &in, const LDefinition &inputCopy,
                  const LDefinition &jumpTablePointer, MTableSwitch *ins) {
         setOperand(0, in);
         setTemp(0, inputCopy);
         setTemp(1, jumpTablePointer);
         setMir(ins);
     }
     MTableSwitch *mir() const {
         return mir_->toTableSwitch();
     }
     const LAllocation *index() {
         return getOperand(0);
     }
     const LDefinition *tempInt() {
         return getTemp(0);
     }
     // This is added to share the same CodeGenerator prefixes.
     const LDefinition *tempPointer() {
         return getTemp(1);
     }
 };
 // Takes a tableswitch with an integer to decide
 class LTableSwitchV : public LInstructionHelper<0, BOX_PIECES, 3>
 {
   public:
     LIR_HEADER(TableSwitchV);
     LTableSwitchV(const LDefinition &inputCopy, const LDefinition &floatCopy,
                   const LDefinition &jumpTablePointer, MTableSwitch *ins)
     {
         setTemp(0, inputCopy);
         setTemp(1, floatCopy);
         setTemp(2, jumpTablePointer);
         setMir(ins);
     }
     MTableSwitch *mir() const {
         return mir_->toTableSwitch();
     }
     static const size_t InputValue = 0;
     const LDefinition *tempInt() {
         return getTemp(0);
     }
     const LDefinition *tempFloat() {
         return getTemp(1);
     }
     const LDefinition *tempPointer() {
         return getTemp(2);
     }
 };
 class LGuardShape : public LInstructionHelper<0, 1, 1>
 {
   public:
     LIR_HEADER(GuardShape);
     LGuardShape(const LAllocation &in, const LDefinition &temp) {
         setOperand(0, in);
         setTemp(0, temp);
     }
     const MGuardShape *mir() const {
         return mir_->toGuardShape();
     }
     const LDefinition *tempInt() {
         return getTemp(0);
     }
 };
 class LGuardObjectType : public LInstructionHelper<0, 1, 1>
 {
   public:
     LIR_HEADER(GuardObjectType);
     LGuardObjectType(const LAllocation &in, const LDefinition &temp) {
         setOperand(0, in);
         setTemp(0, temp);
     }
     const MGuardObjectType *mir() const {
         return mir_->toGuardObjectType();
     }
     const LDefinition *tempInt() {
         return getTemp(0);
     }
 };
 class LInterruptCheck : public LInstructionHelper<0, 0, 0>
 {
   public:
     LIR_HEADER(InterruptCheck);
 };
 class LMulI : public LBinaryMath<0>
 {
   public:
     LIR_HEADER(MulI);
     MMul *mir() {
         return mir_->toMul();
     }
 };
 class LUDiv : public LBinaryMath<0>
 {
   public:
     LIR_HEADER(UDiv);
     MDiv *mir() {
         return mir_->toDiv();
     }
 };
 class LUMod : public LBinaryMath<0>
 {
   public:
     LIR_HEADER(UMod);
     MMod *mir() {
         return mir_->toMod();
     }
 };
 class LAsmJSLoadFuncPtr : public LInstructionHelper<1, 1, 1>
 {
   public:
     LIR_HEADER(AsmJSLoadFuncPtr);
     LAsmJSLoadFuncPtr(const LAllocation &index, const LDefinition &temp) {
         setOperand(0, index);
         setTemp(0, temp);
     }
     const MAsmJSLoadFuncPtr *mir() const {
         return mir_->toAsmJSLoadFuncPtr();
     }
     const LAllocation *index() {
         return getOperand(0);
     }
     const LDefinition *temp() {
         return getTemp(0);
     }
 };
 } // namespace jit
 } // namespace js
 #endif /* jit_mips_LIR_mips_h */

The Tor Browser / annotate

js/src/jit/mips/LIR-mips.h@129ffea94266 (annotated)

js/src/jit/mips/LIR-mips.h