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

js/src/jit/Registers.h@129ffea94266 (annotated)

js/src/jit/Registers.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_Registers_h
 #define jit_Registers_h
 #include "mozilla/Array.h"
 #include "jit/IonTypes.h"
 #if defined(JS_CODEGEN_X86)
 # include "jit/x86/Architecture-x86.h"
 #elif defined(JS_CODEGEN_X64)
 # include "jit/x64/Architecture-x64.h"
 #elif defined(JS_CODEGEN_ARM)
 # include "jit/arm/Architecture-arm.h"
 #elif defined(JS_CODEGEN_MIPS)
 # include "jit/mips/Architecture-mips.h"
 #else
 # error "Unknown architecture!"
 #endif
 namespace js {
 namespace jit {
 struct Register {
     typedef Registers Codes;
     typedef Codes::Code Code;
     Code code_;
     static Register FromCode(uint32_t i) {
         JS_ASSERT(i < Registers::Total);
         Register r = { (Registers::Code)i };
         return r;
     }
     static Register FromName(const char *name) {
         Registers::Code code = Registers::FromName(name);
         Register r = { code };
         return r;
     }
     Code code() const {
         JS_ASSERT((uint32_t)code_ < Registers::Total);
         return code_;
     }
     const char *name() const {
         return Registers::GetName(code());
     }
     bool operator ==(const Register &other) const {
         return code_ == other.code_;
     }
     bool operator !=(const Register &other) const {
         return code_ != other.code_;
     }
     bool volatile_() const {
         return !!((1 << code()) & Registers::VolatileMask);
     }
 };
 struct FloatRegister {
     typedef FloatRegisters Codes;
     typedef Codes::Code Code;
     Code code_;
     static FloatRegister FromCode(uint32_t i) {
         JS_ASSERT(i < FloatRegisters::Total);
         FloatRegister r = { (FloatRegisters::Code)i };
         return r;
     }
     static FloatRegister FromName(const char *name) {
         FloatRegisters::Code code = FloatRegisters::FromName(name);
         FloatRegister r = { code };
         return r;
     }
     Code code() const {
         JS_ASSERT((uint32_t)code_ < FloatRegisters::Total);
         return code_;
     }
     const char *name() const {
         return FloatRegisters::GetName(code());
     }
     bool operator ==(const FloatRegister &other) const {
         return code_ == other.code_;
     }
     bool operator !=(const FloatRegister &other) const {
         return code_ != other.code_;
     }
     bool volatile_() const {
         return !!((1 << code()) & FloatRegisters::VolatileMask);
     }
 };
 class RegisterDump
 {
   protected: // Silence Clang warning.
     mozilla::Array<uintptr_t, Registers::Total> regs_;
     mozilla::Array<double, FloatRegisters::Total> fpregs_;
   public:
     static size_t offsetOfRegister(Register reg) {
         return offsetof(RegisterDump, regs_) + reg.code() * sizeof(uintptr_t);
     }
     static size_t offsetOfRegister(FloatRegister reg) {
         return offsetof(RegisterDump, fpregs_) + reg.code() * sizeof(double);
     }
 };
 // Information needed to recover machine register state.
 class MachineState
 {
     mozilla::Array<uintptr_t *, Registers::Total> regs_;
     mozilla::Array<double *, FloatRegisters::Total> fpregs_;
   public:
     static MachineState FromBailout(mozilla::Array<uintptr_t, Registers::Total> &regs,
                                     mozilla::Array<double, FloatRegisters::Total> &fpregs);
     void setRegisterLocation(Register reg, uintptr_t *up) {
         regs_[reg.code()] = up;
     }
     void setRegisterLocation(FloatRegister reg, double *dp) {
         fpregs_[reg.code()] = dp;
     }
     bool has(Register reg) const {
         return regs_[reg.code()] != nullptr;
     }
     bool has(FloatRegister reg) const {
         return fpregs_[reg.code()] != nullptr;
     }
     uintptr_t read(Register reg) const {
         return *regs_[reg.code()];
     }
     double read(FloatRegister reg) const {
         return *fpregs_[reg.code()];
     }
     void write(Register reg, uintptr_t value) const {
         *regs_[reg.code()] = value;
     }
 };
 } // namespace jit
 } // namespace js
 #endif /* jit_Registers_h */

The Tor Browser / annotate

js/src/jit/Registers.h@129ffea94266 (annotated)

js/src/jit/Registers.h