blob: 88c35d7d6447b38b85dcbabeae591e2c9bc6fc8c [file] [log] [blame]
//===- subzero/src/IceAssembler.cpp - Assembler base class ----------------===//
// 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.
//
// This is forked from Dart revision 39313.
// Please update the revision if we merge back changes from Dart.
// https://code.google.com/p/dart/wiki/GettingTheSource
//
//===----------------------------------------------------------------------===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// \brief Implements the Assembler base class.
///
//===----------------------------------------------------------------------===//
#include "IceAssembler.h"
#include "IceGlobalContext.h"
#include "IceOperand.h"
namespace Ice {
static uintptr_t NewContents(Assembler &Assemblr, intptr_t Capacity) {
uintptr_t Result = Assemblr.allocateBytes(Capacity);
return Result;
}
void Label::linkTo(const Assembler &Asm, intptr_t Pos) {
// We must not set the link until the position is absolutely known. This means
// not during the preliminary (sandboxing) pass, and not when the instruction
// needs a text fixup (hybrid iasm mode).
if (Asm.getPreliminary() || Asm.needsTextFixup())
return;
assert(!isBound());
Position = Pos + kWordSize;
assert(isLinked());
}
void AssemblerBuffer::installFixup(AssemblerFixup *F) {
if (!Assemblr.getPreliminary())
Fixups.push_back(F);
}
AssemblerFixup *AssemblerBuffer::createFixup(FixupKind Kind,
const Constant *Value) {
AssemblerFixup *F =
new (Assemblr.allocate<AssemblerFixup>()) AssemblerFixup();
F->set_kind(Kind);
F->set_value(Value);
installFixup(F);
return F;
}
AssemblerTextFixup *AssemblerBuffer::createTextFixup(const std::string &Text,
size_t BytesUsed) {
AssemblerTextFixup *F = new (Assemblr.allocate<AssemblerTextFixup>())
AssemblerTextFixup(Text, BytesUsed);
installFixup(F);
resetNeedsTextFixup();
return F;
}
void AssemblerBuffer::EnsureCapacity::validate(AssemblerBuffer *buffer) {
// In debug mode, we save the assembler buffer along with the gap size before
// we start emitting to the buffer. This allows us to check that any single
// generated instruction doesn't overflow the limit implied by the minimum
// gap size.
Gap = computeGap();
// Make sure that extending the capacity leaves a big enough gap for any kind
// of instruction.
assert(Gap >= kMinimumGap);
// Mark the buffer as having ensured the capacity.
assert(!buffer->hasEnsuredCapacity()); // Cannot nest.
buffer->HasEnsuredCapacity = true;
}
AssemblerBuffer::EnsureCapacity::~EnsureCapacity() {
// Unmark the buffer, so we cannot emit after this.
Buffer->HasEnsuredCapacity = false;
// Make sure the generated instruction doesn't take up more space than the
// minimum gap.
intptr_t delta = Gap - computeGap();
(void)delta;
assert(delta <= kMinimumGap);
}
AssemblerBuffer::AssemblerBuffer(Assembler &Asm) : Assemblr(Asm) {
constexpr intptr_t OneKB = 1024;
static constexpr intptr_t kInitialBufferCapacity = 4 * OneKB;
Contents = NewContents(Assemblr, kInitialBufferCapacity);
Cursor = Contents;
Limit = computeLimit(Contents, kInitialBufferCapacity);
HasEnsuredCapacity = false;
TextFixupNeeded = false;
// Verify internal state.
assert(capacity() == kInitialBufferCapacity);
assert(size() == 0);
}
AssemblerBuffer::~AssemblerBuffer() = default;
void AssemblerBuffer::extendCapacity() {
intptr_t old_size = size();
intptr_t old_capacity = capacity();
constexpr intptr_t OneMB = 1 << 20;
intptr_t new_capacity = std::min(old_capacity * 2, old_capacity + OneMB);
if (new_capacity < old_capacity) {
llvm::report_fatal_error(
"Unexpected overflow in AssemblerBuffer::ExtendCapacity");
}
// Allocate the new data area and copy contents of the old one to it.
uintptr_t new_contents = NewContents(Assemblr, new_capacity);
memmove(reinterpret_cast<void *>(new_contents),
reinterpret_cast<void *>(Contents), old_size);
// Compute the relocation delta and switch to the new contents area.
intptr_t delta = new_contents - Contents;
Contents = new_contents;
// Update the cursor and recompute the limit.
Cursor += delta;
Limit = computeLimit(new_contents, new_capacity);
// Verify internal state.
assert(capacity() == new_capacity);
assert(size() == old_size);
}
llvm::StringRef Assembler::getBufferView() const {
return llvm::StringRef(reinterpret_cast<const char *>(Buffer.contents()),
Buffer.size());
}
void Assembler::bindRelocOffset(RelocOffset *Offset) {
if (!getPreliminary()) {
Offset->setOffset(Buffer.getPosition());
}
}
void Assembler::emitIASBytes(GlobalContext *Ctx) const {
Ostream &Str = Ctx->getStrEmit();
intptr_t EndPosition = Buffer.size();
intptr_t CurPosition = 0;
for (const AssemblerFixup *NextFixup : fixups()) {
intptr_t NextFixupLoc = NextFixup->position();
for (intptr_t i = CurPosition; i < NextFixupLoc; ++i) {
Str << "\t.byte 0x";
Str.write_hex(Buffer.load<uint8_t>(i));
Str << "\n";
}
CurPosition = NextFixupLoc + NextFixup->emit(Ctx, *this);
assert(CurPosition <= EndPosition);
}
// Handle any bytes that are not prefixed by a fixup.
for (intptr_t i = CurPosition; i < EndPosition; ++i) {
Str << "\t.byte 0x";
Str.write_hex(Buffer.load<uint8_t>(i));
Str << "\n";
}
}
} // end of namespace Ice