Compiler Explorer

Source code

// The following code is from V8, and includes heavily-reduced fragments
// from several files. Copyright headers for those files follow:

// Copyright 2011 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.

// Copyright (c) 1994-2006 Sun Microsystems Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// - Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// - Redistribution in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// - Neither the name of Sun Microsystems or the names of contributors may
// be used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The original source code covered by the above license above has been
// modified significantly by Google Inc.
// Copyright 2012 the V8 project authors. All rights reserved.

#include <cstdint>
#include <cstring>

using Address = uintptr_t;
using byte = uint8_t;

template <typename V>
static inline void WriteUnalignedValue(Address p, V value) {
  memcpy(reinterpret_cast<void*>(p), &value, sizeof(V));
}

class Register {
 public:
  int reg_code_;
};
Register eax;

struct RelocInfo {
  enum Mode : int8_t {
    NONE,  // never recorded value
  };
  static constexpr bool IsNone(Mode mode) { return mode == NONE; }
};

struct Immediate {
  // Calls where x is an Address (uintptr_t) resolve to this overload.
  inline explicit Immediate(int x, RelocInfo::Mode rmode = RelocInfo::NONE) {
    immediate_ = x;
    rmode_ = rmode;
  }

bool is_int8() const {
    return RelocInfo::IsNone(rmode_);
  }

RelocInfo::Mode rmode() const { return rmode_; }

int immediate_;
  bool is_heap_object_request_ = false;
  RelocInfo::Mode rmode_;
};

struct Operand {
  byte buf_[6];
  uint8_t len_ = 0;
  RelocInfo::Mode rmode_ = RelocInfo::NONE;
};

struct Assembler {
  __attribute__((noinline)) void emit_arith(int sel, Operand dst, const Immediate& x);
  __attribute__((noinline)) void emit_operand(Register reg, Operand adr);
  byte* pc_;
};

void Assembler::emit_arith(int sel, Operand dst, const Immediate& x) {
  Register ireg = eax;
  if (x.is_int8()) {
    emit_operand(ireg, dst);
  } else {
    emit_operand(ireg, dst);
  }
}

void Assembler::emit_operand(Register reg, Operand adr) {
  *pc_++ = (adr.buf_[0] & ~0x38) | (reg.reg_code_ << 3);
}