summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asmjit/src/asmjit/core/formatter.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asmjit/src/asmjit/core/formatter.cpp')
-rw-r--r--3rdparty/asmjit/src/asmjit/core/formatter.cpp473
1 files changed, 294 insertions, 179 deletions
diff --git a/3rdparty/asmjit/src/asmjit/core/formatter.cpp b/3rdparty/asmjit/src/asmjit/core/formatter.cpp
index 404edaf3820..0f12e416364 100644
--- a/3rdparty/asmjit/src/asmjit/core/formatter.cpp
+++ b/3rdparty/asmjit/src/asmjit/core/formatter.cpp
@@ -1,44 +1,27 @@
-// AsmJit - Machine code generation for C++
+// This file is part of AsmJit project <https://asmjit.com>
//
-// * Official AsmJit Home Page: https://asmjit.com
-// * Official Github Repository: https://github.com/asmjit/asmjit
-//
-// Copyright (c) 2008-2020 The AsmJit Authors
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-// claim that you wrote the original software. If you use this software
-// in a product, an acknowledgment in the product documentation would be
-// appreciated but is not required.
-// 2. Altered source versions must be plainly marked as such, and must not be
-// misrepresented as being the original software.
-// 3. This notice may not be removed or altered from any source distribution.
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
#include "../core/api-build_p.h"
#ifndef ASMJIT_NO_LOGGING
+#include "../core/archtraits.h"
#include "../core/builder.h"
#include "../core/codeholder.h"
#include "../core/compiler.h"
#include "../core/emitter.h"
-#include "../core/formatter.h"
+#include "../core/formatter_p.h"
#include "../core/string.h"
#include "../core/support.h"
#include "../core/type.h"
-#ifdef ASMJIT_BUILD_X86
+#if !defined(ASMJIT_NO_X86)
#include "../x86/x86formatter_p.h"
#endif
-#ifdef ASMJIT_BUILD_ARM
- #include "../arm/armformatter_p.h"
+#if !defined(ASMJIT_NO_AARCH64)
+ #include "../arm/a64formatter_p.h"
#endif
ASMJIT_BEGIN_NAMESPACE
@@ -47,46 +30,64 @@ ASMJIT_BEGIN_NAMESPACE
class VirtReg;
#endif
-// ============================================================================
-// [asmjit::Formatter]
-// ============================================================================
-
namespace Formatter {
-Error formatTypeId(String& sb, uint32_t typeId) noexcept {
- if (typeId == Type::kIdVoid)
+static const char wordNameTable[][8] = {
+ "db",
+ "dw",
+ "dd",
+ "dq",
+ "byte",
+ "half",
+ "word",
+ "hword",
+ "dword",
+ "qword",
+ "xword",
+ "short",
+ "long",
+ "quad"
+};
+
+
+Error formatTypeId(String& sb, TypeId typeId) noexcept {
+ if (typeId == TypeId::kVoid)
return sb.append("void");
- if (!Type::isValid(typeId))
+ if (!TypeUtils::isValid(typeId))
return sb.append("unknown");
- const char* typeName = "unknown";
- uint32_t typeSize = Type::sizeOf(typeId);
-
- uint32_t baseId = Type::baseOf(typeId);
- switch (baseId) {
- case Type::kIdIntPtr : typeName = "iptr" ; break;
- case Type::kIdUIntPtr: typeName = "uptr" ; break;
- case Type::kIdI8 : typeName = "i8" ; break;
- case Type::kIdU8 : typeName = "u8" ; break;
- case Type::kIdI16 : typeName = "i16" ; break;
- case Type::kIdU16 : typeName = "u16" ; break;
- case Type::kIdI32 : typeName = "i32" ; break;
- case Type::kIdU32 : typeName = "u32" ; break;
- case Type::kIdI64 : typeName = "i64" ; break;
- case Type::kIdU64 : typeName = "u64" ; break;
- case Type::kIdF32 : typeName = "f32" ; break;
- case Type::kIdF64 : typeName = "f64" ; break;
- case Type::kIdF80 : typeName = "f80" ; break;
- case Type::kIdMask8 : typeName = "mask8" ; break;
- case Type::kIdMask16 : typeName = "mask16"; break;
- case Type::kIdMask32 : typeName = "mask32"; break;
- case Type::kIdMask64 : typeName = "mask64"; break;
- case Type::kIdMmx32 : typeName = "mmx32" ; break;
- case Type::kIdMmx64 : typeName = "mmx64" ; break;
+ const char* typeName = nullptr;
+ uint32_t typeSize = TypeUtils::sizeOf(typeId);
+ TypeId scalarType = TypeUtils::scalarOf(typeId);
+
+ switch (scalarType) {
+ case TypeId::kIntPtr : typeName = "intptr" ; break;
+ case TypeId::kUIntPtr: typeName = "uintptr"; break;
+ case TypeId::kInt8 : typeName = "int8" ; break;
+ case TypeId::kUInt8 : typeName = "uint8" ; break;
+ case TypeId::kInt16 : typeName = "int16" ; break;
+ case TypeId::kUInt16 : typeName = "uint16" ; break;
+ case TypeId::kInt32 : typeName = "int32" ; break;
+ case TypeId::kUInt32 : typeName = "uint32" ; break;
+ case TypeId::kInt64 : typeName = "int64" ; break;
+ case TypeId::kUInt64 : typeName = "uint64" ; break;
+ case TypeId::kFloat32: typeName = "float32"; break;
+ case TypeId::kFloat64: typeName = "float64"; break;
+ case TypeId::kFloat80: typeName = "float80"; break;
+ case TypeId::kMask8 : typeName = "mask8" ; break;
+ case TypeId::kMask16 : typeName = "mask16" ; break;
+ case TypeId::kMask32 : typeName = "mask32" ; break;
+ case TypeId::kMask64 : typeName = "mask64" ; break;
+ case TypeId::kMmx32 : typeName = "mmx32" ; break;
+ case TypeId::kMmx64 : typeName = "mmx64" ; break;
+
+ default:
+ typeName = "unknown";
+ break;
}
- uint32_t baseSize = Type::sizeOf(baseId);
+ uint32_t baseSize = TypeUtils::sizeOf(scalarType);
if (typeSize > baseSize) {
uint32_t count = typeSize / baseSize;
return sb.appendFormat("%sx%u", typeName, unsigned(count));
@@ -98,15 +99,15 @@ Error formatTypeId(String& sb, uint32_t typeId) noexcept {
Error formatFeature(
String& sb,
- uint32_t arch,
+ Arch arch,
uint32_t featureId) noexcept {
-#ifdef ASMJIT_BUILD_X86
+#if !defined(ASMJIT_NO_X86)
if (Environment::isFamilyX86(arch))
return x86::FormatterInternal::formatFeature(sb, featureId);
#endif
-#ifdef ASMJIT_BUILD_ARM
+#if !defined(ASMJIT_NO_AARCH64)
if (Environment::isFamilyARM(arch))
return arm::FormatterInternal::formatFeature(sb, featureId);
#endif
@@ -116,51 +117,55 @@ Error formatFeature(
Error formatLabel(
String& sb,
- uint32_t formatFlags,
+ FormatFlags formatFlags,
const BaseEmitter* emitter,
uint32_t labelId) noexcept {
DebugUtils::unused(formatFlags);
- const LabelEntry* le = emitter->code()->labelEntry(labelId);
- if (ASMJIT_UNLIKELY(!le))
- return sb.appendFormat("<InvalidLabel:%u>", labelId);
+ if (emitter && emitter->code()) {
+ const LabelEntry* le = emitter->code()->labelEntry(labelId);
+ if (ASMJIT_UNLIKELY(!le))
+ return sb.appendFormat("<InvalidLabel:%u>", labelId);
- if (le->hasName()) {
- if (le->hasParent()) {
- uint32_t parentId = le->parentId();
- const LabelEntry* pe = emitter->code()->labelEntry(parentId);
+ if (le->hasName()) {
+ if (le->hasParent()) {
+ uint32_t parentId = le->parentId();
+ const LabelEntry* pe = emitter->code()->labelEntry(parentId);
- if (ASMJIT_UNLIKELY(!pe))
- ASMJIT_PROPAGATE(sb.appendFormat("<InvalidLabel:%u>", labelId));
- else if (ASMJIT_UNLIKELY(!pe->hasName()))
- ASMJIT_PROPAGATE(sb.appendFormat("L%u", parentId));
- else
- ASMJIT_PROPAGATE(sb.append(pe->name()));
+ if (ASMJIT_UNLIKELY(!pe))
+ ASMJIT_PROPAGATE(sb.appendFormat("<InvalidLabel:%u>", labelId));
+ else if (ASMJIT_UNLIKELY(!pe->hasName()))
+ ASMJIT_PROPAGATE(sb.appendFormat("L%u", parentId));
+ else
+ ASMJIT_PROPAGATE(sb.append(pe->name()));
- ASMJIT_PROPAGATE(sb.append('.'));
+ ASMJIT_PROPAGATE(sb.append('.'));
+ }
+
+ if (le->type() == LabelType::kAnonymous)
+ ASMJIT_PROPAGATE(sb.appendFormat("L%u@", labelId));
+ return sb.append(le->name());
}
- return sb.append(le->name());
- }
- else {
- return sb.appendFormat("L%u", labelId);
}
+
+ return sb.appendFormat("L%u", labelId);
}
Error formatRegister(
String& sb,
- uint32_t formatFlags,
+ FormatFlags formatFlags,
const BaseEmitter* emitter,
- uint32_t arch,
- uint32_t regType,
+ Arch arch,
+ RegType regType,
uint32_t regId) noexcept {
-#ifdef ASMJIT_BUILD_X86
+#if !defined(ASMJIT_NO_X86)
if (Environment::isFamilyX86(arch))
return x86::FormatterInternal::formatRegister(sb, formatFlags, emitter, arch, regType, regId);
#endif
-#ifdef ASMJIT_BUILD_ARM
+#if !defined(ASMJIT_NO_AARCH64)
if (Environment::isFamilyARM(arch))
return arm::FormatterInternal::formatRegister(sb, formatFlags, emitter, arch, regType, regId);
#endif
@@ -170,17 +175,17 @@ Error formatRegister(
Error formatOperand(
String& sb,
- uint32_t formatFlags,
+ FormatFlags formatFlags,
const BaseEmitter* emitter,
- uint32_t arch,
+ Arch arch,
const Operand_& op) noexcept {
-#ifdef ASMJIT_BUILD_X86
+#if !defined(ASMJIT_NO_X86)
if (Environment::isFamilyX86(arch))
return x86::FormatterInternal::formatOperand(sb, formatFlags, emitter, arch, op);
#endif
-#ifdef ASMJIT_BUILD_ARM
+#if !defined(ASMJIT_NO_AARCH64)
if (Environment::isFamilyARM(arch))
return arm::FormatterInternal::formatOperand(sb, formatFlags, emitter, arch, op);
#endif
@@ -188,29 +193,109 @@ Error formatOperand(
return kErrorInvalidArch;
}
+ASMJIT_API Error formatDataType(
+ String& sb,
+ FormatFlags formatFlags,
+ Arch arch,
+ TypeId typeId) noexcept
+{
+ DebugUtils::unused(formatFlags);
+
+ if (ASMJIT_UNLIKELY(uint32_t(arch) > uint32_t(Arch::kMaxValue)))
+ return DebugUtils::errored(kErrorInvalidArch);
+
+ uint32_t typeSize = TypeUtils::sizeOf(typeId);
+ if (typeSize == 0 || typeSize > 8)
+ return DebugUtils::errored(kErrorInvalidState);
+
+ uint32_t typeSizeLog2 = Support::ctz(typeSize);
+ return sb.append(wordNameTable[size_t(ArchTraits::byArch(arch).typeNameIdByIndex(typeSizeLog2))]);
+}
+
+static Error formatDataHelper(String& sb, const char* typeName, uint32_t typeSize, const uint8_t* data, size_t itemCount) noexcept {
+ sb.append('.');
+ sb.append(typeName);
+ sb.append(' ');
+
+ for (size_t i = 0; i < itemCount; i++) {
+ uint64_t v = 0;
+
+ if (i != 0)
+ ASMJIT_PROPAGATE(sb.append(", ", 2));
+
+ switch (typeSize) {
+ case 1: v = data[0]; break;
+ case 2: v = Support::readU16u(data); break;
+ case 4: v = Support::readU32u(data); break;
+ case 8: v = Support::readU64u(data); break;
+ }
+
+ ASMJIT_PROPAGATE(sb.appendUInt(v, 16, typeSize * 2, StringFormatFlags::kAlternate));
+ data += typeSize;
+ }
+
+ return kErrorOk;
+}
+
+Error formatData(
+ String& sb,
+ FormatFlags formatFlags,
+ Arch arch,
+ TypeId typeId, const void* data, size_t itemCount, size_t repeatCount) noexcept
+{
+ DebugUtils::unused(formatFlags);
+
+ if (ASMJIT_UNLIKELY(!Environment::isDefinedArch(arch)))
+ return DebugUtils::errored(kErrorInvalidArch);
+
+ uint32_t typeSize = TypeUtils::sizeOf(typeId);
+ if (typeSize == 0)
+ return DebugUtils::errored(kErrorInvalidState);
+
+ if (!Support::isPowerOf2(typeSize)) {
+ itemCount *= typeSize;
+ typeSize = 1;
+ }
+
+ while (typeSize > 8u) {
+ typeSize >>= 1;
+ itemCount <<= 1;
+ }
+
+ uint32_t typeSizeLog2 = Support::ctz(typeSize);
+ const char* wordName = wordNameTable[size_t(ArchTraits::byArch(arch).typeNameIdByIndex(typeSizeLog2))];
+
+ if (repeatCount > 1)
+ ASMJIT_PROPAGATE(sb.appendFormat(".repeat %zu ", repeatCount));
+
+ return formatDataHelper(sb, wordName, typeSize, static_cast<const uint8_t*>(data), itemCount);
+}
+
Error formatInstruction(
String& sb,
- uint32_t formatFlags,
+ FormatFlags formatFlags,
const BaseEmitter* emitter,
- uint32_t arch,
+ Arch arch,
const BaseInst& inst, const Operand_* operands, size_t opCount) noexcept {
-#ifdef ASMJIT_BUILD_X86
+#if !defined(ASMJIT_NO_X86)
if (Environment::isFamilyX86(arch))
return x86::FormatterInternal::formatInstruction(sb, formatFlags, emitter, arch, inst, operands, opCount);
#endif
-#ifdef ASMJIT_BUILD_ARM
- if (Environment::isFamilyARM(arch))
- return arm::FormatterInternal::formatInstruction(sb, formatFlags, emitter, arch, inst, operands, opCount);
+#if !defined(ASMJIT_NO_AARCH64)
+ if (Environment::isFamilyAArch64(arch))
+ return a64::FormatterInternal::formatInstruction(sb, formatFlags, emitter, arch, inst, operands, opCount);
#endif
return kErrorInvalidArch;
}
#ifndef ASMJIT_NO_BUILDER
-static Error formatFuncValue(String& sb, uint32_t formatFlags, const BaseEmitter* emitter, FuncValue value) noexcept {
- uint32_t typeId = value.typeId();
+
+#ifndef ASMJIT_NO_COMPILER
+static Error formatFuncValue(String& sb, FormatFlags formatFlags, const BaseEmitter* emitter, FuncValue value) noexcept {
+ TypeId typeId = value.typeId();
ASMJIT_PROPAGATE(formatTypeId(sb, typeId));
if (value.isAssigned()) {
@@ -237,84 +322,100 @@ static Error formatFuncValue(String& sb, uint32_t formatFlags, const BaseEmitter
return kErrorOk;
}
-static Error formatFuncRets(
+static Error formatFuncValuePack(
String& sb,
- uint32_t formatFlags,
- const BaseEmitter* emitter,
- const FuncDetail& fd,
- VirtReg* const* vRegs) noexcept {
+ FormatFlags formatFlags,
+ const BaseCompiler* cc,
+ const FuncValuePack& pack,
+ const RegOnly* vRegs) noexcept {
- if (!fd.hasRet())
+ size_t count = pack.count();
+ if (!count)
return sb.append("void");
- for (uint32_t i = 0; i < fd.retCount(); i++) {
- if (i) ASMJIT_PROPAGATE(sb.append(", "));
- ASMJIT_PROPAGATE(formatFuncValue(sb, formatFlags, emitter, fd.ret(i)));
+ if (count > 1)
+ sb.append('[');
+
+ for (uint32_t valueIndex = 0; valueIndex < count; valueIndex++) {
+ const FuncValue& value = pack[valueIndex];
+ if (!value)
+ break;
+
+ if (valueIndex)
+ ASMJIT_PROPAGATE(sb.append(", "));
+
+ ASMJIT_PROPAGATE(formatFuncValue(sb, formatFlags, cc, value));
-#ifndef ASMJIT_NO_COMPILER
if (vRegs) {
- static const char nullRet[] = "<none>";
- ASMJIT_PROPAGATE(sb.appendFormat(" %s", vRegs[i] ? vRegs[i]->name() : nullRet));
+ const VirtReg* virtReg = nullptr;
+ static const char nullReg[] = "<none>";
+
+ if (vRegs[valueIndex].isReg() && cc->isVirtIdValid(vRegs[valueIndex].id()))
+ virtReg = cc->virtRegById(vRegs[valueIndex].id());
+
+ ASMJIT_PROPAGATE(sb.appendFormat(" %s", virtReg ? virtReg->name() : nullReg));
}
-#else
- DebugUtils::unused(vRegs);
-#endif
}
+ if (count > 1)
+ sb.append(']');
+
return kErrorOk;
}
+static Error formatFuncRets(
+ String& sb,
+ FormatFlags formatFlags,
+ const BaseCompiler* cc,
+ const FuncDetail& fd) noexcept {
+
+ return formatFuncValuePack(sb, formatFlags, cc, fd.retPack(), nullptr);
+}
+
static Error formatFuncArgs(
String& sb,
- uint32_t formatFlags,
- const BaseEmitter* emitter,
+ FormatFlags formatFlags,
+ const BaseCompiler* cc,
const FuncDetail& fd,
- VirtReg* const* vRegs) noexcept {
+ const FuncNode::ArgPack* argPacks) noexcept {
- uint32_t count = fd.argCount();
- if (!count)
+ uint32_t argCount = fd.argCount();
+ if (!argCount)
return sb.append("void");
- for (uint32_t i = 0; i < count; i++) {
- if (i)
+ for (uint32_t argIndex = 0; argIndex < argCount; argIndex++) {
+ if (argIndex)
ASMJIT_PROPAGATE(sb.append(", "));
- ASMJIT_PROPAGATE(formatFuncValue(sb, formatFlags, emitter, fd.arg(i)));
-
-#ifndef ASMJIT_NO_COMPILER
- if (vRegs) {
- static const char nullArg[] = "<none>";
- ASMJIT_PROPAGATE(sb.appendFormat(" %s", vRegs[i] ? vRegs[i]->name() : nullArg));
- }
-#else
- DebugUtils::unused(vRegs);
-#endif
+ ASMJIT_PROPAGATE(formatFuncValuePack(sb, formatFlags, cc, fd.argPack(argIndex), argPacks[argIndex]._data));
}
return kErrorOk;
}
+#endif
Error formatNode(
String& sb,
- uint32_t formatFlags,
+ const FormatOptions& formatOptions,
const BaseBuilder* builder,
const BaseNode* node) noexcept {
- if (node->hasPosition() && (formatFlags & FormatOptions::kFlagPositions) != 0)
+ if (node->hasPosition() && formatOptions.hasFlag(FormatFlags::kPositions))
ASMJIT_PROPAGATE(sb.appendFormat("<%05u> ", node->position()));
+ size_t startLineIndex = sb.size();
+
switch (node->type()) {
- case BaseNode::kNodeInst:
- case BaseNode::kNodeJump: {
+ case NodeType::kInst:
+ case NodeType::kJump: {
const InstNode* instNode = node->as<InstNode>();
- ASMJIT_PROPAGATE(
- formatInstruction(sb, formatFlags, builder,
- builder->arch(),
- instNode->baseInst(), instNode->operands(), instNode->opCount()));
+ ASMJIT_PROPAGATE(builder->_funcs.formatInstruction(sb, formatOptions.flags(), builder,
+ builder->arch(),
+ instNode->baseInst(), instNode->operands(), instNode->opCount()));
break;
}
- case BaseNode::kNodeSection: {
+ case NodeType::kSection: {
const SectionNode* sectionNode = node->as<SectionNode>();
if (builder->_code->isSectionValid(sectionNode->id())) {
const Section* section = builder->_code->sectionById(sectionNode->id());
@@ -323,60 +424,63 @@ Error formatNode(
break;
}
- case BaseNode::kNodeLabel: {
+ case NodeType::kLabel: {
const LabelNode* labelNode = node->as<LabelNode>();
- ASMJIT_PROPAGATE(formatLabel(sb, formatFlags, builder, labelNode->labelId()));
+ ASMJIT_PROPAGATE(formatLabel(sb, formatOptions.flags(), builder, labelNode->labelId()));
ASMJIT_PROPAGATE(sb.append(":"));
break;
}
- case BaseNode::kNodeAlign: {
+ case NodeType::kAlign: {
const AlignNode* alignNode = node->as<AlignNode>();
- ASMJIT_PROPAGATE(
- sb.appendFormat("align %u (%s)",
- alignNode->alignment(),
- alignNode->alignMode() == kAlignCode ? "code" : "data"));
+ ASMJIT_PROPAGATE(sb.appendFormat(".align %u (%s)",
+ alignNode->alignment(),
+ alignNode->alignMode() == AlignMode::kCode ? "code" : "data"));
break;
}
- case BaseNode::kNodeEmbedData: {
+ case NodeType::kEmbedData: {
const EmbedDataNode* embedNode = node->as<EmbedDataNode>();
- ASMJIT_PROPAGATE(sb.append("embed "));
- if (embedNode->repeatCount() != 1)
- ASMJIT_PROPAGATE(sb.appendFormat("[repeat=%zu] ", size_t(embedNode->repeatCount())));
- ASMJIT_PROPAGATE(sb.appendFormat("%u bytes", embedNode->dataSize()));
+ ASMJIT_PROPAGATE(sb.append('.'));
+ ASMJIT_PROPAGATE(formatDataType(sb, formatOptions.flags(), builder->arch(), embedNode->typeId()));
+ ASMJIT_PROPAGATE(sb.appendFormat(" {Count=%zu Repeat=%zu TotalSize=%zu}", embedNode->itemCount(), embedNode->repeatCount(), embedNode->dataSize()));
break;
}
- case BaseNode::kNodeEmbedLabel: {
+ case NodeType::kEmbedLabel: {
const EmbedLabelNode* embedNode = node->as<EmbedLabelNode>();
ASMJIT_PROPAGATE(sb.append(".label "));
- ASMJIT_PROPAGATE(formatLabel(sb, formatFlags, builder, embedNode->labelId()));
+ ASMJIT_PROPAGATE(formatLabel(sb, formatOptions.flags(), builder, embedNode->labelId()));
break;
}
- case BaseNode::kNodeEmbedLabelDelta: {
+ case NodeType::kEmbedLabelDelta: {
const EmbedLabelDeltaNode* embedNode = node->as<EmbedLabelDeltaNode>();
ASMJIT_PROPAGATE(sb.append(".label ("));
- ASMJIT_PROPAGATE(formatLabel(sb, formatFlags, builder, embedNode->labelId()));
+ ASMJIT_PROPAGATE(formatLabel(sb, formatOptions.flags(), builder, embedNode->labelId()));
ASMJIT_PROPAGATE(sb.append(" - "));
- ASMJIT_PROPAGATE(formatLabel(sb, formatFlags, builder, embedNode->baseLabelId()));
+ ASMJIT_PROPAGATE(formatLabel(sb, formatOptions.flags(), builder, embedNode->baseLabelId()));
ASMJIT_PROPAGATE(sb.append(")"));
break;
}
- case BaseNode::kNodeComment: {
- const CommentNode* commentNode = node->as<CommentNode>();
- ASMJIT_PROPAGATE(sb.appendFormat("; %s", commentNode->inlineComment()));
+ case NodeType::kConstPool: {
+ const ConstPoolNode* constPoolNode = node->as<ConstPoolNode>();
+ ASMJIT_PROPAGATE(sb.appendFormat("[ConstPool Size=%zu Alignment=%zu]", constPoolNode->size(), constPoolNode->alignment()));
break;
+ };
+
+ case NodeType::kComment: {
+ const CommentNode* commentNode = node->as<CommentNode>();
+ return sb.appendFormat("; %s", commentNode->inlineComment());
}
- case BaseNode::kNodeSentinel: {
+ case NodeType::kSentinel: {
const SentinelNode* sentinelNode = node->as<SentinelNode>();
const char* sentinelName = nullptr;
switch (sentinelNode->sentinelType()) {
- case SentinelNode::kSentinelFuncEnd:
+ case SentinelType::kFuncEnd:
sentinelName = "[FuncEnd]";
break;
@@ -390,39 +494,40 @@ Error formatNode(
}
#ifndef ASMJIT_NO_COMPILER
- case BaseNode::kNodeFunc: {
+ case NodeType::kFunc: {
const FuncNode* funcNode = node->as<FuncNode>();
- ASMJIT_PROPAGATE(formatLabel(sb, formatFlags, builder, funcNode->labelId()));
- ASMJIT_PROPAGATE(sb.append(": "));
+ if (builder->isCompiler()) {
+ ASMJIT_PROPAGATE(formatLabel(sb, formatOptions.flags(), builder, funcNode->labelId()));
+ ASMJIT_PROPAGATE(sb.append(": "));
- ASMJIT_PROPAGATE(formatFuncRets(sb, formatFlags, builder, funcNode->detail(), nullptr));
- ASMJIT_PROPAGATE(sb.append(" Func("));
- ASMJIT_PROPAGATE(formatFuncArgs(sb, formatFlags, builder, funcNode->detail(), funcNode->args()));
- ASMJIT_PROPAGATE(sb.append(")"));
+ ASMJIT_PROPAGATE(formatFuncRets(sb, formatOptions.flags(), static_cast<const BaseCompiler*>(builder), funcNode->detail()));
+ ASMJIT_PROPAGATE(sb.append(" Func("));
+ ASMJIT_PROPAGATE(formatFuncArgs(sb, formatOptions.flags(), static_cast<const BaseCompiler*>(builder), funcNode->detail(), funcNode->argPacks()));
+ ASMJIT_PROPAGATE(sb.append(")"));
+ }
break;
}
- case BaseNode::kNodeFuncRet: {
+ case NodeType::kFuncRet: {
const FuncRetNode* retNode = node->as<FuncRetNode>();
ASMJIT_PROPAGATE(sb.append("[FuncRet]"));
for (uint32_t i = 0; i < 2; i++) {
- const Operand_& op = retNode->_opArray[i];
+ const Operand_& op = retNode->op(i);
if (!op.isNone()) {
ASMJIT_PROPAGATE(sb.append(i == 0 ? " " : ", "));
- ASMJIT_PROPAGATE(formatOperand(sb, formatFlags, builder, builder->arch(), op));
+ ASMJIT_PROPAGATE(formatOperand(sb, formatOptions.flags(), builder, builder->arch(), op));
}
}
break;
}
- case BaseNode::kNodeInvoke: {
+ case NodeType::kInvoke: {
const InvokeNode* invokeNode = node->as<InvokeNode>();
- ASMJIT_PROPAGATE(
- formatInstruction(sb, formatFlags, builder,
- builder->arch(),
- invokeNode->baseInst(), invokeNode->operands(), invokeNode->opCount()));
+ ASMJIT_PROPAGATE(builder->_funcs.formatInstruction(sb, formatOptions.flags(), builder,
+ builder->arch(),
+ invokeNode->baseInst(), invokeNode->operands(), invokeNode->opCount()));
break;
}
#endif
@@ -433,28 +538,38 @@ Error formatNode(
}
}
+ if (node->hasInlineComment()) {
+ size_t requiredPadding = paddingFromOptions(formatOptions, FormatPaddingGroup::kRegularLine);
+ size_t currentPadding = sb.size() - startLineIndex;
+
+ if (currentPadding < requiredPadding)
+ ASMJIT_PROPAGATE(sb.appendChars(' ', requiredPadding - currentPadding));
+
+ ASMJIT_PROPAGATE(sb.append("; "));
+ ASMJIT_PROPAGATE(sb.append(node->inlineComment()));
+ }
+
return kErrorOk;
}
-
Error formatNodeList(
String& sb,
- uint32_t formatFlags,
+ const FormatOptions& formatOptions,
const BaseBuilder* builder) noexcept {
- return formatNodeList(sb, formatFlags, builder, builder->firstNode(), nullptr);
+ return formatNodeList(sb, formatOptions, builder, builder->firstNode(), nullptr);
}
Error formatNodeList(
String& sb,
- uint32_t formatFlags,
+ const FormatOptions& formatOptions,
const BaseBuilder* builder,
const BaseNode* begin,
const BaseNode* end) noexcept {
const BaseNode* node = begin;
while (node != end) {
- ASMJIT_PROPAGATE(formatNode(sb, formatFlags, builder, node));
+ ASMJIT_PROPAGATE(formatNode(sb, formatOptions, builder, node));
ASMJIT_PROPAGATE(sb.append('\n'));
node = node->next();
}