v8/src/macro-assembler.h
jgruber 3f99a376dd Reland "[builtins] Introduce further constant & external reference indirections"
This is a reland of f5d308510a

Original change's description:
> [builtins] Introduce further constant & external reference indirections
>
> This introduces further indirections for embedded constants and
> external references for builtins generated by the macro-assembler.
> The used mechanisms (LookupConstant and LookupExternalReference) are
> identical to what we already use in CSA.
>
> Almost all builtins are now isolate-independent in both release and
> debug modes. snapshot_blob.bin is roughly 670K smaller in embedded
> builds vs. non-embedded builds, while libv8.so is roughly 280K larger.
>
> Bug: v8:6666
> Change-Id: I7a6c2193ef5a763e6cf7543dd51597d6fff6c110
> Reviewed-on: https://chromium-review.googlesource.com/1006581
> Commit-Queue: Jakob Gruber <jgruber@chromium.org>
> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#52810}

TBR=mstarzinger@chromium.org

Bug: v8:6666
Change-Id: I73dfe207f2c5f79a9a06c165c75f5619e88a5a17
Reviewed-on: https://chromium-review.googlesource.com/1030550
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Commit-Queue: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/master@{#52819}
2018-04-26 15:27:22 +00:00

240 lines
6.9 KiB
C++

// Copyright 2012 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.
#ifndef V8_MACRO_ASSEMBLER_H_
#define V8_MACRO_ASSEMBLER_H_
#include "src/assembler.h"
#include "src/frames.h"
#include "src/heap/heap.h"
// Helper types to make boolean flag easier to read at call-site.
enum InvokeFlag {
CALL_FUNCTION,
JUMP_FUNCTION
};
// Flags used for the AllocateInNewSpace functions.
enum AllocationFlags {
// No special flags.
NO_ALLOCATION_FLAGS = 0,
// The content of the result register already contains the allocation top in
// new space.
RESULT_CONTAINS_TOP = 1 << 0,
// Specify that the requested size of the space to allocate is specified in
// words instead of bytes.
SIZE_IN_WORDS = 1 << 1,
// Align the allocation to a multiple of kDoubleSize
DOUBLE_ALIGNMENT = 1 << 2,
// Directly allocate in old space
PRETENURE = 1 << 3,
};
#if V8_TARGET_ARCH_IA32
#include "src/ia32/macro-assembler-ia32.h"
#elif V8_TARGET_ARCH_X64
#include "src/x64/macro-assembler-x64.h"
#elif V8_TARGET_ARCH_ARM64
#include "src/arm64/constants-arm64.h"
#include "src/arm64/macro-assembler-arm64.h"
#elif V8_TARGET_ARCH_ARM
#include "src/arm/constants-arm.h"
#include "src/arm/macro-assembler-arm.h"
#elif V8_TARGET_ARCH_PPC
#include "src/ppc/constants-ppc.h"
#include "src/ppc/macro-assembler-ppc.h"
#elif V8_TARGET_ARCH_MIPS
#include "src/mips/constants-mips.h"
#include "src/mips/macro-assembler-mips.h"
#elif V8_TARGET_ARCH_MIPS64
#include "src/mips64/constants-mips64.h"
#include "src/mips64/macro-assembler-mips64.h"
#elif V8_TARGET_ARCH_S390
#include "src/s390/constants-s390.h"
#include "src/s390/macro-assembler-s390.h"
#else
#error Unsupported target architecture.
#endif
namespace v8 {
namespace internal {
// Simulators only support C calls with up to kMaxCParameters parameters.
static constexpr int kMaxCParameters = 9;
class FrameScope {
public:
explicit FrameScope(TurboAssembler* tasm, StackFrame::Type type)
: tasm_(tasm), type_(type), old_has_frame_(tasm->has_frame()) {
tasm->set_has_frame(true);
if (type != StackFrame::MANUAL && type_ != StackFrame::NONE) {
tasm->EnterFrame(type);
}
}
~FrameScope() {
if (type_ != StackFrame::MANUAL && type_ != StackFrame::NONE) {
tasm_->LeaveFrame(type_);
}
tasm_->set_has_frame(old_has_frame_);
}
// Normally we generate the leave-frame code when this object goes
// out of scope. Sometimes we may need to generate the code somewhere else
// in addition. Calling this will achieve that, but the object stays in
// scope, the MacroAssembler is still marked as being in a frame scope, and
// the code will be generated again when it goes out of scope.
void GenerateLeaveFrame() {
DCHECK(type_ != StackFrame::MANUAL && type_ != StackFrame::NONE);
tasm_->LeaveFrame(type_);
}
private:
TurboAssembler* tasm_;
StackFrame::Type type_;
bool old_has_frame_;
};
class FrameAndConstantPoolScope {
public:
FrameAndConstantPoolScope(MacroAssembler* masm, StackFrame::Type type)
: masm_(masm),
type_(type),
old_has_frame_(masm->has_frame()),
old_constant_pool_available_(FLAG_enable_embedded_constant_pool &&
masm->is_constant_pool_available()) {
masm->set_has_frame(true);
if (FLAG_enable_embedded_constant_pool) {
masm->set_constant_pool_available(true);
}
if (type_ != StackFrame::MANUAL && type_ != StackFrame::NONE) {
masm->EnterFrame(type, !old_constant_pool_available_);
}
}
~FrameAndConstantPoolScope() {
masm_->LeaveFrame(type_);
masm_->set_has_frame(old_has_frame_);
if (FLAG_enable_embedded_constant_pool) {
masm_->set_constant_pool_available(old_constant_pool_available_);
}
}
// Normally we generate the leave-frame code when this object goes
// out of scope. Sometimes we may need to generate the code somewhere else
// in addition. Calling this will achieve that, but the object stays in
// scope, the MacroAssembler is still marked as being in a frame scope, and
// the code will be generated again when it goes out of scope.
void GenerateLeaveFrame() {
DCHECK(type_ != StackFrame::MANUAL && type_ != StackFrame::NONE);
masm_->LeaveFrame(type_);
}
private:
MacroAssembler* masm_;
StackFrame::Type type_;
bool old_has_frame_;
bool old_constant_pool_available_;
DISALLOW_IMPLICIT_CONSTRUCTORS(FrameAndConstantPoolScope);
};
// Class for scoping the the unavailability of constant pool access.
class ConstantPoolUnavailableScope {
public:
explicit ConstantPoolUnavailableScope(Assembler* assembler)
: assembler_(assembler),
old_constant_pool_available_(FLAG_enable_embedded_constant_pool &&
assembler->is_constant_pool_available()) {
if (FLAG_enable_embedded_constant_pool) {
assembler->set_constant_pool_available(false);
}
}
~ConstantPoolUnavailableScope() {
if (FLAG_enable_embedded_constant_pool) {
assembler_->set_constant_pool_available(old_constant_pool_available_);
}
}
private:
Assembler* assembler_;
int old_constant_pool_available_;
DISALLOW_IMPLICIT_CONSTRUCTORS(ConstantPoolUnavailableScope);
};
class AllowExternalCallThatCantCauseGC: public FrameScope {
public:
explicit AllowExternalCallThatCantCauseGC(MacroAssembler* masm)
: FrameScope(masm, StackFrame::NONE) { }
};
class NoCurrentFrameScope {
public:
explicit NoCurrentFrameScope(MacroAssembler* masm)
: masm_(masm), saved_(masm->has_frame()) {
masm->set_has_frame(false);
}
~NoCurrentFrameScope() {
masm_->set_has_frame(saved_);
}
private:
MacroAssembler* masm_;
bool saved_;
};
// Prevent the use of the RootArray during the lifetime of this
// scope object.
class NoRootArrayScope {
public:
explicit NoRootArrayScope(MacroAssembler* masm)
: masm_(masm), old_value_(masm->root_array_available()) {
masm->set_root_array_available(false);
}
~NoRootArrayScope() { masm_->set_root_array_available(old_value_); }
private:
MacroAssembler* masm_;
bool old_value_;
};
// Wrapper class for passing expected and actual parameter counts as
// either registers or immediate values. Used to make sure that the
// caller provides exactly the expected number of parameters to the
// callee.
class ParameterCount BASE_EMBEDDED {
public:
explicit ParameterCount(Register reg) : reg_(reg), immediate_(0) {}
explicit ParameterCount(int imm) : reg_(no_reg), immediate_(imm) {}
bool is_reg() const { return reg_.is_valid(); }
bool is_immediate() const { return !is_reg(); }
Register reg() const {
DCHECK(is_reg());
return reg_;
}
int immediate() const {
DCHECK(is_immediate());
return immediate_;
}
private:
const Register reg_;
const int immediate_;
DISALLOW_IMPLICIT_CONSTRUCTORS(ParameterCount);
};
} // namespace internal
} // namespace v8
#endif // V8_MACRO_ASSEMBLER_H_