blob: 4e57a0cef74bba50ee0a9689ac045aac2bb41345 [file] [log] [blame]
//===- subzero/src/IceAssembler.h - Integrated assembler --------*- C++ -*-===//
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// Modified by the Subzero authors.
// The Subzero Code Generator
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
/// \file
/// \brief Declares the Assembler base class.
/// Instructions are assembled by architecture-specific assemblers that derive
/// from this base class. This base class manages buffers and fixups for
/// emitting code, etc.
#include "IceDefs.h"
#include "IceFixups.h"
#include "IceStringPool.h"
#include "IceUtils.h"
#include "llvm/Support/Allocator.h"
namespace Ice {
class Assembler;
/// A Label can be in one of three states:
/// - Unused.
/// - Linked, unplaced and tracking the position of branches to the label.
/// - Bound, placed and tracking its position.
class Label {
Label(const Label &) = delete;
Label &operator=(const Label &) = delete;
Label() = default;
virtual ~Label() = default;
virtual void finalCheck() const {
// Assert if label is being destroyed with unresolved branches pending.
/// Returns the encoded position stored in the label.
intptr_t getEncodedPosition() const { return Position; }
/// Returns the position for bound labels (branches that come after this are
/// considered backward branches). Cannot be used for unused or linked labels.
intptr_t getPosition() const {
return -Position - kWordSize;
/// Returns the position of an earlier branch instruction that was linked to
/// this label (branches that use this are considered forward branches). The
/// linked instructions form a linked list, of sorts, using the instruction's
/// displacement field for the location of the next instruction that is also
/// linked to this label.
intptr_t getLinkPosition() const {
return Position - kWordSize;
void setPosition(intptr_t NewValue) { Position = NewValue; }
bool isBound() const { return Position < 0; }
bool isLinked() const { return Position > 0; }
virtual bool isUnused() const { return Position == 0; }
void bindTo(intptr_t position) {
Position = -position - kWordSize;
void linkTo(const Assembler &Asm, intptr_t position);
intptr_t Position = 0;
// TODO(jvoung): why are labels offset by this?
static constexpr uint32_t kWordSize = sizeof(uint32_t);
/// Assembler buffers are used to emit binary code. They grow on demand.
class AssemblerBuffer {
AssemblerBuffer(const AssemblerBuffer &) = delete;
AssemblerBuffer &operator=(const AssemblerBuffer &) = delete;
AssemblerBuffer(Assembler &);
/// \name Basic support for emitting, loading, and storing.
/// @{
// These use memcpy instead of assignment to avoid undefined behaviour of
// assigning to unaligned addresses. Since the size of the copy is known the
// compiler can inline the memcpy with simple moves.
template <typename T> void emit(T Value) {
memcpy(reinterpret_cast<void *>(Cursor), &Value, sizeof(T));
Cursor += sizeof(T);
template <typename T> T load(intptr_t Position) const {
assert(Position >= 0 &&
Position <= (size() - static_cast<intptr_t>(sizeof(T))));
T Value;
memcpy(&Value, reinterpret_cast<void *>(Contents + Position), sizeof(T));
return Value;
template <typename T> void store(intptr_t Position, T Value) {
assert(Position >= 0 &&
Position <= (size() - static_cast<intptr_t>(sizeof(T))));
memcpy(reinterpret_cast<void *>(Contents + Position), &Value, sizeof(T));
/// @{
/// Emit a fixup at the current location.
void emitFixup(AssemblerFixup *Fixup) { Fixup->set_position(size()); }
/// Get the size of the emitted code.
intptr_t size() const { return Cursor - Contents; }
uintptr_t contents() const { return Contents; }
/// To emit an instruction to the assembler buffer, the EnsureCapacity helper
/// must be used to guarantee that the underlying data area is big enough to
/// hold the emitted instruction. Usage:
/// AssemblerBuffer buffer;
/// AssemblerBuffer::EnsureCapacity ensured(&buffer);
/// ... emit bytes for single instruction ...
class EnsureCapacity {
EnsureCapacity(const EnsureCapacity &) = delete;
EnsureCapacity &operator=(const EnsureCapacity &) = delete;
explicit EnsureCapacity(AssemblerBuffer *Buffer) : Buffer(Buffer) {
if (Buffer->cursor() >= Buffer->limit())
if (BuildDefs::asserts())
AssemblerBuffer *Buffer;
intptr_t Gap = 0;
void validate(AssemblerBuffer *Buffer);
intptr_t computeGap() { return Buffer->capacity() - Buffer->size(); }
bool HasEnsuredCapacity;
bool hasEnsuredCapacity() const {
if (BuildDefs::asserts())
return HasEnsuredCapacity;
// Disable the actual check in non-debug mode.
return true;
/// Returns the position in the instruction stream.
intptr_t getPosition() const { return Cursor - Contents; }
/// Create and track a fixup in the current function.
AssemblerFixup *createFixup(FixupKind Kind, const Constant *Value);
/// Create and track a textual fixup in the current function.
AssemblerTextFixup *createTextFixup(const std::string &Text,
size_t BytesUsed);
/// Mark that an attempt was made to emit, but failed. Hence, in order to
/// continue, one must emit a text fixup.
void setNeedsTextFixup() { TextFixupNeeded = true; }
void resetNeedsTextFixup() { TextFixupNeeded = false; }
/// Returns true if last emit failed and needs a text fixup.
bool needsTextFixup() const { return TextFixupNeeded; }
/// Installs a created fixup, after it has been allocated.
void installFixup(AssemblerFixup *F);
const FixupRefList &fixups() const { return Fixups; }
void setSize(intptr_t NewSize) {
assert(NewSize <= size());
Cursor = Contents + NewSize;
/// The limit is set to kMinimumGap bytes before the end of the data area.
/// This leaves enough space for the longest possible instruction and allows
/// for a single, fast space check per instruction.
static constexpr intptr_t kMinimumGap = 32;
uintptr_t Contents;
uintptr_t Cursor;
uintptr_t Limit;
// The member variable is named Assemblr to avoid hiding the class Assembler.
Assembler &Assemblr;
/// List of pool-allocated fixups relative to the current function.
FixupRefList Fixups;
// True if a textual fixup is needed, because the assembler was unable to
// emit the last request.
bool TextFixupNeeded;
uintptr_t cursor() const { return Cursor; }
uintptr_t limit() const { return Limit; }
intptr_t capacity() const {
assert(Limit >= Contents);
return (Limit - Contents) + kMinimumGap;
/// Compute the limit based on the data area and the capacity. See description
/// of kMinimumGap for the reasoning behind the value.
static uintptr_t computeLimit(uintptr_t Data, intptr_t Capacity) {
return Data + Capacity - kMinimumGap;
void extendCapacity();
class Assembler {
Assembler() = delete;
Assembler(const Assembler &) = delete;
Assembler &operator=(const Assembler &) = delete;
enum AssemblerKind {
virtual ~Assembler() = default;
/// Allocate a chunk of bytes using the per-Assembler allocator.
uintptr_t allocateBytes(size_t bytes) {
// For now, alignment is not related to NaCl bundle alignment, since the
// buffer's GetPosition is relative to the base. So NaCl bundle alignment
// checks can be relative to that base. Later, the buffer will be copied
// out to a ".text" section (or an in memory-buffer that can be mprotect'ed
// with executable permission), and that second buffer should be aligned
// for NaCl.
const size_t Alignment = 16;
return reinterpret_cast<uintptr_t>(Allocator.Allocate(bytes, Alignment));
/// Allocate data of type T using the per-Assembler allocator.
template <typename T> T *allocate() { return Allocator.Allocate<T>(); }
/// Align the tail end of the function to the required target alignment.
virtual void alignFunction() = 0;
/// Align the tail end of the basic block to the required target alignment.
void alignCfgNode() {
const SizeT Align = 1 << getBundleAlignLog2Bytes();
padWithNop(Utils::OffsetToAlignment(Buffer.getPosition(), Align));
/// Add nop padding of a particular width to the current bundle.
virtual void padWithNop(intptr_t Padding) = 0;
virtual SizeT getBundleAlignLog2Bytes() const = 0;
virtual const char *getAlignDirective() const = 0;
virtual llvm::ArrayRef<uint8_t> getNonExecBundlePadding() const = 0;
/// Get the label for a CfgNode.
virtual Label *getCfgNodeLabel(SizeT NodeNumber) = 0;
/// Mark the current text location as the start of a CFG node.
virtual void bindCfgNodeLabel(const CfgNode *Node) = 0;
virtual bool fixupIsPCRel(FixupKind Kind) const = 0;
/// Return a view of all the bytes of code for the current function.
llvm::StringRef getBufferView() const;
/// Return the value of the given type in the corresponding buffer.
template <typename T> T load(intptr_t Position) const {
return Buffer.load<T>(Position);
template <typename T> void store(intptr_t Position, T Value) {, Value);
/// Emit a fixup at the current location.
void emitFixup(AssemblerFixup *Fixup) { Buffer.emitFixup(Fixup); }
const FixupRefList &fixups() const { return Buffer.fixups(); }
AssemblerFixup *createFixup(FixupKind Kind, const Constant *Value) {
return Buffer.createFixup(Kind, Value);
AssemblerTextFixup *createTextFixup(const std::string &Text,
size_t BytesUsed) {
return Buffer.createTextFixup(Text, BytesUsed);
void bindRelocOffset(RelocOffset *Offset);
void setNeedsTextFixup() { Buffer.setNeedsTextFixup(); }
void resetNeedsTextFixup() { Buffer.resetNeedsTextFixup(); }
bool needsTextFixup() const { return Buffer.needsTextFixup(); }
void emitIASBytes(GlobalContext *Ctx) const;
bool getInternal() const { return IsInternal; }
void setInternal(bool Internal) { IsInternal = Internal; }
GlobalString getFunctionName() const { return FunctionName; }
void setFunctionName(GlobalString NewName) { FunctionName = NewName; }
intptr_t getBufferSize() const { return Buffer.size(); }
/// Roll back to a (smaller) size.
void setBufferSize(intptr_t NewSize) { Buffer.setSize(NewSize); }
void setPreliminary(bool Value) { Preliminary = Value; }
bool getPreliminary() const { return Preliminary; }
AssemblerKind getKind() const { return Kind; }
explicit Assembler(AssemblerKind Kind)
: Kind(Kind), Allocator(), Buffer(*this) {}
const AssemblerKind Kind;
using AssemblerAllocator =
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, /*SlabSize=*/32 * 1024>;
AssemblerAllocator Allocator;
/// FunctionName and IsInternal are transferred from the original Cfg object,
/// since the Cfg object may be deleted by the time the assembler buffer is
/// emitted.
GlobalString FunctionName;
bool IsInternal = false;
/// Preliminary indicates whether a preliminary pass is being made for
/// calculating bundle padding (Preliminary=true), versus the final pass where
/// all changes to label bindings, label links, and relocation fixups are
/// fully committed (Preliminary=false).
bool Preliminary = false;
/// Installs a created fixup, after it has been allocated.
void installFixup(AssemblerFixup *F) { Buffer.installFixup(F); }
// Buffer's constructor uses the Allocator, so it needs to appear after it.
// TODO(jpp): dependencies on construction order are a nice way of shooting
// yourself in the foot. Fix this.
AssemblerBuffer Buffer;
} // end of namespace Ice