summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asmjit/src/asmjit/core/builder.h
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asmjit/src/asmjit/core/builder.h')
-rw-r--r--3rdparty/asmjit/src/asmjit/core/builder.h1148
1 files changed, 612 insertions, 536 deletions
diff --git a/3rdparty/asmjit/src/asmjit/core/builder.h b/3rdparty/asmjit/src/asmjit/core/builder.h
index ba99267dafa..0de19234cb6 100644
--- a/3rdparty/asmjit/src/asmjit/core/builder.h
+++ b/3rdparty/asmjit/src/asmjit/core/builder.h
@@ -1,25 +1,7 @@
-// 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
#ifndef ASMJIT_CORE_BUILDER_H_INCLUDED
#define ASMJIT_CORE_BUILDER_H_INCLUDED
@@ -44,10 +26,6 @@ ASMJIT_BEGIN_NAMESPACE
//! \addtogroup asmjit_builder
//! \{
-// ============================================================================
-// [Forward Declarations]
-// ============================================================================
-
class BaseBuilder;
class Pass;
@@ -63,30 +41,155 @@ class CommentNode;
class SentinelNode;
class LabelDeltaNode;
-// Only used by Compiler infrastructure.
-class JumpAnnotation;
+//! Type of node used by \ref BaseBuilder and \ref BaseCompiler.
+enum class NodeType : uint8_t {
+ //! Invalid node (internal, don't use).
+ kNone = 0,
+
+ // [BaseBuilder]
+
+ //! Node is \ref InstNode.
+ kInst = 1,
+ //! Node is \ref SectionNode.
+ kSection = 2,
+ //! Node is \ref LabelNode.
+ kLabel = 3,
+ //! Node is \ref AlignNode.
+ kAlign = 4,
+ //! Node is \ref EmbedDataNode.
+ kEmbedData = 5,
+ //! Node is \ref EmbedLabelNode.
+ kEmbedLabel = 6,
+ //! Node is \ref EmbedLabelDeltaNode.
+ kEmbedLabelDelta = 7,
+ //! Node is \ref ConstPoolNode.
+ kConstPool = 8,
+ //! Node is \ref CommentNode.
+ kComment = 9,
+ //! Node is \ref SentinelNode.
+ kSentinel = 10,
+
+ // [BaseCompiler]
+
+ //! Node is \ref JumpNode (acts as InstNode).
+ kJump = 15,
+ //! Node is \ref FuncNode (acts as LabelNode).
+ kFunc = 16,
+ //! Node is \ref FuncRetNode (acts as InstNode).
+ kFuncRet = 17,
+ //! Node is \ref InvokeNode (acts as InstNode).
+ kInvoke = 18,
+
+ // [UserDefined]
+
+ //! First id of a user-defined node.
+ kUser = 32
+};
+
+//! Node flags, specify what the node is and/or does.
+enum class NodeFlags : uint8_t {
+ //! No flags.
+ kNone = 0,
+ //! Node is code that can be executed (instruction, label, align, etc...).
+ kIsCode = 0x01u,
+ //! Node is data that cannot be executed (data, const-pool, etc...).
+ kIsData = 0x02u,
+ //! Node is informative, can be removed and ignored.
+ kIsInformative = 0x04u,
+ //! Node can be safely removed if unreachable.
+ kIsRemovable = 0x08u,
+ //! Node does nothing when executed (label, align, explicit nop).
+ kHasNoEffect = 0x10u,
+ //! Node is an instruction or acts as it.
+ kActsAsInst = 0x20u,
+ //! Node is a label or acts as it.
+ kActsAsLabel = 0x40u,
+ //! Node is active (part of the code).
+ kIsActive = 0x80u
+};
+ASMJIT_DEFINE_ENUM_FLAGS(NodeFlags)
+
+//! Type of the sentinel (purely informative purpose).
+enum class SentinelType : uint8_t {
+ //! Type of the sentinel is not known.
+ kUnknown = 0u,
+ //! This is a sentinel used at the end of \ref FuncNode.
+ kFuncEnd = 1u
+};
+
+//! Node list.
+//!
+//! A double-linked list of pointers to \ref BaseNode, managed by \ref BaseBuilder or \ref BaseCompiler.
+//!
+//! \note At the moment NodeList is just a view, but it's planned that it will get more functionality in the future.
+class NodeList {
+public:
+ //! \name Members
+ //! \{
+
+ //! First node in the list or nullptr if there are no nodes in the list.
+ BaseNode* _first = nullptr;
+ //! Last node in the list or nullptr if there are no nodes in the list.
+ BaseNode* _last = nullptr;
-// ============================================================================
-// [asmjit::BaseBuilder]
-// ============================================================================
+ //! \}
+
+ //! \name Construction & Destruction
+ //! \{
+
+ ASMJIT_INLINE_NODEBUG NodeList() noexcept {}
+
+ ASMJIT_INLINE_NODEBUG NodeList(BaseNode* first, BaseNode* last) noexcept
+ : _first(first),
+ _last(last) {}
+
+ //! \}
+
+ //! \name Reset
+ //! \{
+
+ ASMJIT_INLINE_NODEBUG void reset() noexcept {
+ _first = nullptr;
+ _last = nullptr;
+ }
+
+ ASMJIT_INLINE_NODEBUG void reset(BaseNode* first, BaseNode* last) noexcept {
+ _first = first;
+ _last = last;
+ }
+
+ //! \}
+
+ //! \name Accessors
+ //! \{
+
+ ASMJIT_INLINE_NODEBUG bool empty() const noexcept { return _first == nullptr; }
+
+ ASMJIT_INLINE_NODEBUG BaseNode* first() const noexcept { return _first; }
+ ASMJIT_INLINE_NODEBUG BaseNode* last() const noexcept { return _last; }
+
+ //! \}
+};
//! Builder interface.
//!
-//! `BaseBuilder` interface was designed to be used as a \ref BaseAssembler
-//! replacement in case pre-processing or post-processing of the generated code
-//! is required. The code can be modified during or after code generation. Pre
-//! or post processing can be done manually or through a \ref Pass object. \ref
-//! BaseBuilder stores the emitted code as a double-linked list of nodes, which
-//! allows O(1) insertion and removal during processing.
+//! `BaseBuilder` interface was designed to be used as a \ref BaseAssembler replacement in case pre-processing or
+//! post-processing of the generated code is required. The code can be modified during or after code generation.
+//! Pre processing or post processing can be done manually or through a \ref Pass object. \ref BaseBuilder stores
+//! the emitted code as a double-linked list of nodes, which allows O(1) insertion and removal during processing.
//!
//! Check out architecture specific builders for more details and examples:
//!
//! - \ref x86::Builder - X86/X64 builder implementation.
+//! - \ref a64::Builder - AArch64 builder implementation.
class ASMJIT_VIRTAPI BaseBuilder : public BaseEmitter {
public:
ASMJIT_NONCOPYABLE(BaseBuilder)
typedef BaseEmitter Base;
+ //! \name Members
+ //! \{
+
//! Base zone used to allocate nodes and passes.
Zone _codeZone;
//! Data zone used to allocate data and names.
@@ -97,23 +200,23 @@ public:
ZoneAllocator _allocator;
//! Array of `Pass` objects.
- ZoneVector<Pass*> _passes;
+ ZoneVector<Pass*> _passes {};
//! Maps section indexes to `LabelNode` nodes.
- ZoneVector<SectionNode*> _sectionNodes;
+ ZoneVector<SectionNode*> _sectionNodes {};
//! Maps label indexes to `LabelNode` nodes.
- ZoneVector<LabelNode*> _labelNodes;
+ ZoneVector<LabelNode*> _labelNodes {};
//! Current node (cursor).
- BaseNode* _cursor;
- //! First node of the current section.
- BaseNode* _firstNode;
- //! Last node of the current section.
- BaseNode* _lastNode;
+ BaseNode* _cursor = nullptr;
+ //! First and last nodes.
+ NodeList _nodeList;
//! Flags assigned to each new node.
- uint32_t _nodeFlags;
+ NodeFlags _nodeFlags = NodeFlags::kNone;
//! The sections links are dirty (used internally).
- bool _dirtySectionLinks;
+ bool _dirtySectionLinks = false;
+
+ //! \}
//! \name Construction & Destruction
//! \{
@@ -121,28 +224,29 @@ public:
//! Creates a new `BaseBuilder` instance.
ASMJIT_API BaseBuilder() noexcept;
//! Destroys the `BaseBuilder` instance.
- ASMJIT_API virtual ~BaseBuilder() noexcept;
+ ASMJIT_API ~BaseBuilder() noexcept override;
//! \}
//! \name Node Management
//! \{
+ ASMJIT_INLINE_NODEBUG NodeList nodeList() const noexcept { return _nodeList; }
+
//! Returns the first node.
- inline BaseNode* firstNode() const noexcept { return _firstNode; }
+ ASMJIT_INLINE_NODEBUG BaseNode* firstNode() const noexcept { return _nodeList.first(); }
//! Returns the last node.
- inline BaseNode* lastNode() const noexcept { return _lastNode; }
+ ASMJIT_INLINE_NODEBUG BaseNode* lastNode() const noexcept { return _nodeList.last(); }
- //! Allocates and instantiates a new node of type `T` and returns its instance.
- //! If the allocation fails `nullptr` is returned.
+ //! Allocates and instantiates a new node of type `T` and returns its instance. If the allocation fails `nullptr`
+ //! is returned.
//!
//! The template argument `T` must be a type that is extends \ref BaseNode.
//!
- //! \remarks The pointer returned (if non-null) is owned by the Builder or
- //! Compiler. When the Builder/Compiler is destroyed it destroys all nodes
- //! it created so no manual memory management is required.
+ //! \remarks The pointer returned (if non-null) is owned by the Builder or Compiler. When the Builder/Compiler
+ //! is destroyed it destroys all nodes it created so no manual memory management is required.
template<typename T, typename... Args>
- inline Error _newNodeT(T** out, Args&&... args) {
+ inline Error _newNodeT(T** ASMJIT_NONNULL(out), Args&&... args) {
*out = _allocator.newT<T>(this, std::forward<Args>(args)...);
if (ASMJIT_UNLIKELY(!*out))
return reportError(DebugUtils::errored(kErrorOutOfMemory));
@@ -150,50 +254,44 @@ public:
}
//! Creates a new \ref InstNode.
- ASMJIT_API Error _newInstNode(InstNode** out, uint32_t instId, uint32_t instOptions, uint32_t opCount);
+ ASMJIT_API Error newInstNode(InstNode** ASMJIT_NONNULL(out), InstId instId, InstOptions instOptions, uint32_t opCount);
//! Creates a new \ref LabelNode.
- ASMJIT_API Error _newLabelNode(LabelNode** out);
+ ASMJIT_API Error newLabelNode(LabelNode** ASMJIT_NONNULL(out));
//! Creates a new \ref AlignNode.
- ASMJIT_API Error _newAlignNode(AlignNode** out, uint32_t alignMode, uint32_t alignment);
+ ASMJIT_API Error newAlignNode(AlignNode** ASMJIT_NONNULL(out), AlignMode alignMode, uint32_t alignment);
//! Creates a new \ref EmbedDataNode.
- ASMJIT_API Error _newEmbedDataNode(EmbedDataNode** out, uint32_t typeId, const void* data, size_t itemCount, size_t repeatCount = 1);
+ ASMJIT_API Error newEmbedDataNode(EmbedDataNode** ASMJIT_NONNULL(out), TypeId typeId, const void* data, size_t itemCount, size_t repeatCount = 1);
//! Creates a new \ref ConstPoolNode.
- ASMJIT_API Error _newConstPoolNode(ConstPoolNode** out);
+ ASMJIT_API Error newConstPoolNode(ConstPoolNode** ASMJIT_NONNULL(out));
//! Creates a new \ref CommentNode.
- ASMJIT_API Error _newCommentNode(CommentNode** out, const char* data, size_t size);
+ ASMJIT_API Error newCommentNode(CommentNode** ASMJIT_NONNULL(out), const char* data, size_t size);
//! Adds `node` after the current and sets the current node to the given `node`.
- ASMJIT_API BaseNode* addNode(BaseNode* node) noexcept;
+ ASMJIT_API BaseNode* addNode(BaseNode* ASMJIT_NONNULL(node)) noexcept;
//! Inserts the given `node` after `ref`.
- ASMJIT_API BaseNode* addAfter(BaseNode* node, BaseNode* ref) noexcept;
+ ASMJIT_API BaseNode* addAfter(BaseNode* ASMJIT_NONNULL(node), BaseNode* ASMJIT_NONNULL(ref)) noexcept;
//! Inserts the given `node` before `ref`.
- ASMJIT_API BaseNode* addBefore(BaseNode* node, BaseNode* ref) noexcept;
+ ASMJIT_API BaseNode* addBefore(BaseNode* ASMJIT_NONNULL(node), BaseNode* ASMJIT_NONNULL(ref)) noexcept;
//! Removes the given `node`.
- ASMJIT_API BaseNode* removeNode(BaseNode* node) noexcept;
+ ASMJIT_API BaseNode* removeNode(BaseNode* ASMJIT_NONNULL(node)) noexcept;
//! Removes multiple nodes.
ASMJIT_API void removeNodes(BaseNode* first, BaseNode* last) noexcept;
//! Returns the cursor.
//!
- //! When the Builder/Compiler is created it automatically creates a '.text'
- //! \ref SectionNode, which will be the initial one. When instructions are
- //! added they are always added after the cursor and the cursor is changed
- //! to be that newly added node. Use `setCursor()` to change where new nodes
- //! are inserted.
- inline BaseNode* cursor() const noexcept {
- return _cursor;
- }
+ //! When the Builder/Compiler is created it automatically creates a '.text' \ref SectionNode, which will be the
+ //! initial one. When instructions are added they are always added after the cursor and the cursor is changed
+ //! to be that newly added node. Use `setCursor()` to change where new nodes are inserted.
+ ASMJIT_INLINE_NODEBUG BaseNode* cursor() const noexcept { return _cursor; }
//! Sets the current node to `node` and return the previous one.
ASMJIT_API BaseNode* setCursor(BaseNode* node) noexcept;
//! Sets the current node without returning the previous node.
//!
- //! Only use this function if you are concerned about performance and want
- //! this inlined (for example if you set the cursor in a loop, etc...).
- inline void _setCursor(BaseNode* node) noexcept {
- _cursor = node;
- }
+ //! Only use this function if you are concerned about performance and want this inlined (for example if you set
+ //! the cursor in a loop, etc...).
+ ASMJIT_INLINE_NODEBUG void _setCursor(BaseNode* node) noexcept { _cursor = node; }
//! \}
@@ -202,29 +300,28 @@ public:
//! Returns a vector of SectionNode objects.
//!
- //! \note If a section of some id is not associated with the Builder/Compiler
- //! it would be null, so always check for nulls if you iterate over the vector.
- inline const ZoneVector<SectionNode*>& sectionNodes() const noexcept {
+ //! \note If a section of some id is not associated with the Builder/Compiler it would be null, so always check
+ //! for nulls if you iterate over the vector.
+ ASMJIT_INLINE_NODEBUG const ZoneVector<SectionNode*>& sectionNodes() const noexcept {
return _sectionNodes;
}
//! Tests whether the `SectionNode` of the given `sectionId` was registered.
- inline bool hasRegisteredSectionNode(uint32_t sectionId) const noexcept {
+ ASMJIT_INLINE_NODEBUG bool hasRegisteredSectionNode(uint32_t sectionId) const noexcept {
return sectionId < _sectionNodes.size() && _sectionNodes[sectionId] != nullptr;
}
//! Returns or creates a `SectionNode` that matches the given `sectionId`.
//!
- //! \remarks This function will either get the existing `SectionNode` or create
- //! it in case it wasn't created before. You can check whether a section has a
- //! registered `SectionNode` by using `BaseBuilder::hasRegisteredSectionNode()`.
- ASMJIT_API Error sectionNodeOf(SectionNode** out, uint32_t sectionId);
+ //! \remarks This function will either get the existing `SectionNode` or create it in case it wasn't created before.
+ //! You can check whether a section has a registered `SectionNode` by using `BaseBuilder::hasRegisteredSectionNode()`.
+ ASMJIT_API Error sectionNodeOf(SectionNode** ASMJIT_NONNULL(out), uint32_t sectionId);
- ASMJIT_API Error section(Section* section) override;
+ ASMJIT_API Error section(Section* ASMJIT_NONNULL(section)) override;
- //! Returns whether the section links of active section nodes are dirty. You can
- //! update these links by calling `updateSectionLinks()` in such case.
- inline bool hasDirtySectionLinks() const noexcept { return _dirtySectionLinks; }
+ //! Returns whether the section links of active section nodes are dirty. You can update these links by calling
+ //! `updateSectionLinks()` in such case.
+ ASMJIT_INLINE_NODEBUG bool hasDirtySectionLinks() const noexcept { return _dirtySectionLinks; }
//! Updates links of all active section nodes.
ASMJIT_API void updateSectionLinks() noexcept;
@@ -236,41 +333,39 @@ public:
//! Returns a vector of \ref LabelNode nodes.
//!
- //! \note If a label of some id is not associated with the Builder/Compiler
- //! it would be null, so always check for nulls if you iterate over the vector.
- inline const ZoneVector<LabelNode*>& labelNodes() const noexcept { return _labelNodes; }
+ //! \note If a label of some id is not associated with the Builder/Compiler it would be null, so always check for
+ //! nulls if you iterate over the vector.
+ ASMJIT_INLINE_NODEBUG const ZoneVector<LabelNode*>& labelNodes() const noexcept { return _labelNodes; }
//! Tests whether the `LabelNode` of the given `labelId` was registered.
- inline bool hasRegisteredLabelNode(uint32_t labelId) const noexcept {
+ ASMJIT_INLINE_NODEBUG bool hasRegisteredLabelNode(uint32_t labelId) const noexcept {
return labelId < _labelNodes.size() && _labelNodes[labelId] != nullptr;
}
//! \overload
- inline bool hasRegisteredLabelNode(const Label& label) const noexcept {
+ ASMJIT_INLINE_NODEBUG bool hasRegisteredLabelNode(const Label& label) const noexcept {
return hasRegisteredLabelNode(label.id());
}
//! Gets or creates a \ref LabelNode that matches the given `labelId`.
//!
- //! \remarks This function will either get the existing `LabelNode` or create
- //! it in case it wasn't created before. You can check whether a label has a
- //! registered `LabelNode` by calling \ref BaseBuilder::hasRegisteredLabelNode().
- ASMJIT_API Error labelNodeOf(LabelNode** out, uint32_t labelId);
+ //! \remarks This function will either get the existing `LabelNode` or create it in case it wasn't created before.
+ //! You can check whether a label has a registered `LabelNode` by calling \ref BaseBuilder::hasRegisteredLabelNode().
+ ASMJIT_API Error labelNodeOf(LabelNode** ASMJIT_NONNULL(out), uint32_t labelId);
//! \overload
- inline Error labelNodeOf(LabelNode** out, const Label& label) {
+ ASMJIT_INLINE_NODEBUG Error labelNodeOf(LabelNode** ASMJIT_NONNULL(out), const Label& label) {
return labelNodeOf(out, label.id());
}
//! Registers this \ref LabelNode (internal).
//!
- //! This function is used internally to register a newly created `LabelNode`
- //! with this instance of Builder/Compiler. Use \ref labelNodeOf() functions
- //! to get back \ref LabelNode from a label or its identifier.
- ASMJIT_API Error registerLabelNode(LabelNode* node);
+ //! This function is used internally to register a newly created `LabelNode` with this instance of Builder/Compiler.
+ //! Use \ref labelNodeOf() functions to get back \ref LabelNode from a label or its identifier.
+ ASMJIT_API Error registerLabelNode(LabelNode* ASMJIT_NONNULL(node));
ASMJIT_API Label newLabel() override;
- ASMJIT_API Label newNamedLabel(const char* name, size_t nameSize = SIZE_MAX, uint32_t type = Label::kTypeGlobal, uint32_t parentId = Globals::kInvalidId) override;
+ ASMJIT_API Label newNamedLabel(const char* name, size_t nameSize = SIZE_MAX, LabelType type = LabelType::kGlobal, uint32_t parentId = Globals::kInvalidId) override;
ASMJIT_API Error bind(const Label& label) override;
//! \}
@@ -279,16 +374,15 @@ public:
//! \{
//! Returns a vector of `Pass` instances that will be executed by `runPasses()`.
- inline const ZoneVector<Pass*>& passes() const noexcept { return _passes; }
+ ASMJIT_INLINE_NODEBUG const ZoneVector<Pass*>& passes() const noexcept { return _passes; }
- //! Allocates and instantiates a new pass of type `T` and returns its instance.
- //! If the allocation fails `nullptr` is returned.
+ //! Allocates and instantiates a new pass of type `T` and returns its instance. If the allocation fails `nullptr` is
+ //! returned.
//!
//! The template argument `T` must be a type that is extends \ref Pass.
//!
- //! \remarks The pointer returned (if non-null) is owned by the Builder or
- //! Compiler. When the Builder/Compiler is destroyed it destroys all passes
- //! it created so no manual memory management is required.
+ //! \remarks The pointer returned (if non-null) is owned by the Builder or Compiler. When the Builder/Compiler is
+ //! destroyed it destroys all passes it created so no manual memory management is required.
template<typename T>
inline T* newPassT() noexcept { return _codeZone.newT<T>(); }
@@ -319,14 +413,14 @@ public:
//! \name Emit
//! \{
- ASMJIT_API Error _emit(uint32_t instId, const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_* opExt) override;
+ ASMJIT_API Error _emit(InstId instId, const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_* opExt) override;
//! \}
//! \name Align
//! \{
- ASMJIT_API Error align(uint32_t alignMode, uint32_t alignment) override;
+ ASMJIT_API Error align(AlignMode alignMode, uint32_t alignment) override;
//! \}
@@ -334,11 +428,11 @@ public:
//! \{
ASMJIT_API Error embed(const void* data, size_t dataSize) override;
- ASMJIT_API Error embedDataArray(uint32_t typeId, const void* data, size_t count, size_t repeat = 1) override;
+ ASMJIT_API Error embedDataArray(TypeId typeId, const void* data, size_t count, size_t repeat = 1) override;
ASMJIT_API Error embedConstPool(const Label& label, const ConstPool& pool) override;
- ASMJIT_API Error embedLabel(const Label& label) override;
- ASMJIT_API Error embedLabelDelta(const Label& label, const Label& base, size_t dataSize) override;
+ ASMJIT_API Error embedLabel(const Label& label, size_t dataSize = 0) override;
+ ASMJIT_API Error embedLabelDelta(const Label& label, const Label& base, size_t dataSize = 0) override;
//! \}
@@ -354,10 +448,9 @@ public:
//! Serializes everything the given emitter `dst`.
//!
- //! Although not explicitly required the emitter will most probably be of
- //! Assembler type. The reason is that there is no known use of serializing
- //! nodes held by Builder/Compiler into another Builder-like emitter.
- ASMJIT_API Error serialize(BaseEmitter* dst);
+ //! Although not explicitly required the emitter will most probably be of Assembler type. The reason is that
+ //! there is no known use of serializing nodes held by Builder/Compiler into another Builder-like emitter.
+ ASMJIT_API Error serializeTo(BaseEmitter* dst);
//! \}
@@ -368,32 +461,21 @@ public:
ASMJIT_API Error onDetach(CodeHolder* code) noexcept override;
//! \}
-
-#ifndef ASMJIT_NO_DEPRECATED
-#ifndef ASMJIT_NO_LOGGING
- ASMJIT_DEPRECATED("Use Formatter::formatNodeList(sb, formatFlags, builder)")
- inline Error dump(String& sb, uint32_t formatFlags = 0) const noexcept {
- return Formatter::formatNodeList(sb, formatFlags, this);
- }
-#endif // !ASMJIT_NO_LOGGING
-#endif // !ASMJIT_NO_DEPRECATED
};
-// ============================================================================
-// [asmjit::BaseNode]
-// ============================================================================
-
//! Base node.
//!
-//! Every node represents a building-block used by \ref BaseBuilder. It can
-//! be instruction, data, label, comment, directive, or any other high-level
-//! representation that can be transformed to the building blocks mentioned.
-//! Every class that inherits \ref BaseBuilder can define its own high-level
-//! nodes that can be later lowered to basic nodes like instructions.
+//! Every node represents a building-block used by \ref BaseBuilder. It can be instruction, data, label, comment,
+//! directive, or any other high-level representation that can be transformed to the building blocks mentioned.
+//! Every class that inherits \ref BaseBuilder can define its own high-level nodes that can be later lowered to
+//! basic nodes like instructions.
class BaseNode {
public:
ASMJIT_NONCOPYABLE(BaseNode)
+ //! \name Members
+ //! \{
+
union {
struct {
//! Previous node.
@@ -407,22 +489,34 @@ public:
//! Data shared between all types of nodes.
struct AnyData {
- //! Node type, see \ref NodeType.
- uint8_t _nodeType;
- //! Node flags, see \ref Flags.
- uint8_t _nodeFlags;
+ //! Node type.
+ NodeType _nodeType;
+ //! Node flags.
+ NodeFlags _nodeFlags;
//! Not used by BaseNode.
uint8_t _reserved0;
//! Not used by BaseNode.
uint8_t _reserved1;
};
+ //! Data used by \ref AlignNode.
+ struct AlignData {
+ //! Node type.
+ NodeType _nodeType;
+ //! Node flags.
+ NodeFlags _nodeFlags;
+ //! Align mode.
+ AlignMode _alignMode;
+ //! Not used by AlignNode.
+ uint8_t _reserved;
+ };
+
//! Data used by \ref InstNode.
struct InstData {
- //! Node type, see \ref NodeType.
- uint8_t _nodeType;
- //! Node flags, see \ref Flags.
- uint8_t _nodeFlags;
+ //! Node type.
+ NodeType _nodeType;
+ //! Node flags.
+ NodeFlags _nodeFlags;
//! Instruction operands count (used).
uint8_t _opCount;
//! Instruction operands capacity (allocated).
@@ -431,32 +525,34 @@ public:
//! Data used by \ref EmbedDataNode.
struct EmbedData {
- //! Node type, see \ref NodeType.
- uint8_t _nodeType;
- //! Node flags, see \ref Flags.
- uint8_t _nodeFlags;
- //! Type id, see \ref Type::Id.
- uint8_t _typeId;
+ //! Node type.
+ NodeType _nodeType;
+ //! Node flags.
+ NodeFlags _nodeFlags;
+ //! Type id.
+ TypeId _typeId;
//! Size of `_typeId`.
uint8_t _typeSize;
};
//! Data used by \ref SentinelNode.
struct SentinelData {
- //! Node type, see \ref NodeType.
- uint8_t _nodeType;
- //! Node flags, see \ref Flags.
- uint8_t _nodeFlags;
+ //! Node type.
+ NodeType _nodeType;
+ //! Node flags.
+ NodeFlags _nodeFlags;
//! Sentinel type.
- uint8_t _sentinelType;
+ SentinelType _sentinelType;
//! Not used by BaseNode.
uint8_t _reserved1;
};
- //! Data that can have different meaning dependning on \ref NodeType.
+ //! Data that can have different meaning depending on \ref NodeType.
union {
//! Data useful by any node type.
AnyData _any;
+ //! Data specific to \ref AlignNode.
+ AlignData _alignData;
//! Data specific to \ref InstNode.
InstData _inst;
//! Data specific to \ref EmbedDataNode.
@@ -482,84 +578,17 @@ public:
//! Inline comment/annotation or nullptr if not used.
const char* _inlineComment;
- //! Type of `BaseNode`.
- enum NodeType : uint32_t {
- //! Invalid node (internal, don't use).
- kNodeNone = 0,
-
- // [BaseBuilder]
-
- //! Node is \ref InstNode or \ref InstExNode.
- kNodeInst = 1,
- //! Node is \ref SectionNode.
- kNodeSection = 2,
- //! Node is \ref LabelNode.
- kNodeLabel = 3,
- //! Node is \ref AlignNode.
- kNodeAlign = 4,
- //! Node is \ref EmbedDataNode.
- kNodeEmbedData = 5,
- //! Node is \ref EmbedLabelNode.
- kNodeEmbedLabel = 6,
- //! Node is \ref EmbedLabelDeltaNode.
- kNodeEmbedLabelDelta = 7,
- //! Node is \ref ConstPoolNode.
- kNodeConstPool = 8,
- //! Node is \ref CommentNode.
- kNodeComment = 9,
- //! Node is \ref SentinelNode.
- kNodeSentinel = 10,
-
- // [BaseCompiler]
-
- //! Node is \ref JumpNode (acts as InstNode).
- kNodeJump = 15,
- //! Node is \ref FuncNode (acts as LabelNode).
- kNodeFunc = 16,
- //! Node is \ref FuncRetNode (acts as InstNode).
- kNodeFuncRet = 17,
- //! Node is \ref InvokeNode (acts as InstNode).
- kNodeInvoke = 18,
-
- // [UserDefined]
-
- //! First id of a user-defined node.
- kNodeUser = 32,
-
-#ifndef ASMJIT_NO_DEPRECATED
- kNodeFuncCall = kNodeInvoke
-#endif // !ASMJIT_NO_DEPRECATED
- };
-
- //! Node flags, specify what the node is and/or does.
- enum Flags : uint32_t {
- //! Node is code that can be executed (instruction, label, align, etc...).
- kFlagIsCode = 0x01u,
- //! Node is data that cannot be executed (data, const-pool, etc...).
- kFlagIsData = 0x02u,
- //! Node is informative, can be removed and ignored.
- kFlagIsInformative = 0x04u,
- //! Node can be safely removed if unreachable.
- kFlagIsRemovable = 0x08u,
- //! Node does nothing when executed (label, align, explicit nop).
- kFlagHasNoEffect = 0x10u,
- //! Node is an instruction or acts as it.
- kFlagActsAsInst = 0x20u,
- //! Node is a label or acts as it.
- kFlagActsAsLabel = 0x40u,
- //! Node is active (part of the code).
- kFlagIsActive = 0x80u
- };
+ //! \}
//! \name Construction & Destruction
//! \{
//! Creates a new `BaseNode` - always use `BaseBuilder` to allocate nodes.
- ASMJIT_INLINE BaseNode(BaseBuilder* cb, uint32_t type, uint32_t flags = 0) noexcept {
+ ASMJIT_INLINE_NODEBUG BaseNode(BaseBuilder* cb, NodeType nodeType, NodeFlags nodeFlags = NodeFlags::kNone) noexcept {
_prev = nullptr;
_next = nullptr;
- _any._nodeType = uint8_t(type);
- _any._nodeFlags = uint8_t(flags | cb->_nodeFlags);
+ _any._nodeType = nodeType;
+ _any._nodeFlags = nodeFlags | cb->_nodeFlags;
_any._reserved0 = 0;
_any._reserved1 = 0;
_position = 0;
@@ -575,152 +604,141 @@ public:
//! Casts this node to `T*`.
template<typename T>
- inline T* as() noexcept { return static_cast<T*>(this); }
+ ASMJIT_INLINE_NODEBUG T* as() noexcept { return static_cast<T*>(this); }
//! Casts this node to `const T*`.
template<typename T>
- inline const T* as() const noexcept { return static_cast<const T*>(this); }
+ ASMJIT_INLINE_NODEBUG const T* as() const noexcept { return static_cast<const T*>(this); }
//! Returns previous node or `nullptr` if this node is either first or not
//! part of Builder/Compiler node-list.
- inline BaseNode* prev() const noexcept { return _prev; }
+ ASMJIT_INLINE_NODEBUG BaseNode* prev() const noexcept { return _prev; }
//! Returns next node or `nullptr` if this node is either last or not part
//! of Builder/Compiler node-list.
- inline BaseNode* next() const noexcept { return _next; }
+ ASMJIT_INLINE_NODEBUG BaseNode* next() const noexcept { return _next; }
//! Returns the type of the node, see `NodeType`.
- inline uint32_t type() const noexcept { return _any._nodeType; }
+ ASMJIT_INLINE_NODEBUG NodeType type() const noexcept { return _any._nodeType; }
//! Sets the type of the node, see `NodeType` (internal).
//!
- //! \remarks You should never set a type of a node to anything else than the
- //! initial value. This function is only provided for users that use custom
- //! nodes and need to change the type either during construction or later.
- inline void setType(uint32_t type) noexcept { _any._nodeType = uint8_t(type); }
+ //! \remarks You should never set a type of a node to anything else than the initial value. This function is only
+ //! provided for users that use custom nodes and need to change the type either during construction or later.
+ ASMJIT_INLINE_NODEBUG void setType(NodeType type) noexcept { _any._nodeType = type; }
//! Tests whether this node is either `InstNode` or extends it.
- inline bool isInst() const noexcept { return hasFlag(kFlagActsAsInst); }
+ ASMJIT_INLINE_NODEBUG bool isInst() const noexcept { return hasFlag(NodeFlags::kActsAsInst); }
//! Tests whether this node is `SectionNode`.
- inline bool isSection() const noexcept { return type() == kNodeSection; }
+ ASMJIT_INLINE_NODEBUG bool isSection() const noexcept { return type() == NodeType::kSection; }
//! Tests whether this node is either `LabelNode` or extends it.
- inline bool isLabel() const noexcept { return hasFlag(kFlagActsAsLabel); }
+ ASMJIT_INLINE_NODEBUG bool isLabel() const noexcept { return hasFlag(NodeFlags::kActsAsLabel); }
//! Tests whether this node is `AlignNode`.
- inline bool isAlign() const noexcept { return type() == kNodeAlign; }
+ ASMJIT_INLINE_NODEBUG bool isAlign() const noexcept { return type() == NodeType::kAlign; }
//! Tests whether this node is `EmbedDataNode`.
- inline bool isEmbedData() const noexcept { return type() == kNodeEmbedData; }
+ ASMJIT_INLINE_NODEBUG bool isEmbedData() const noexcept { return type() == NodeType::kEmbedData; }
//! Tests whether this node is `EmbedLabelNode`.
- inline bool isEmbedLabel() const noexcept { return type() == kNodeEmbedLabel; }
+ ASMJIT_INLINE_NODEBUG bool isEmbedLabel() const noexcept { return type() == NodeType::kEmbedLabel; }
//! Tests whether this node is `EmbedLabelDeltaNode`.
- inline bool isEmbedLabelDelta() const noexcept { return type() == kNodeEmbedLabelDelta; }
+ ASMJIT_INLINE_NODEBUG bool isEmbedLabelDelta() const noexcept { return type() == NodeType::kEmbedLabelDelta; }
//! Tests whether this node is `ConstPoolNode`.
- inline bool isConstPool() const noexcept { return type() == kNodeConstPool; }
+ ASMJIT_INLINE_NODEBUG bool isConstPool() const noexcept { return type() == NodeType::kConstPool; }
//! Tests whether this node is `CommentNode`.
- inline bool isComment() const noexcept { return type() == kNodeComment; }
+ ASMJIT_INLINE_NODEBUG bool isComment() const noexcept { return type() == NodeType::kComment; }
//! Tests whether this node is `SentinelNode`.
- inline bool isSentinel() const noexcept { return type() == kNodeSentinel; }
+ ASMJIT_INLINE_NODEBUG bool isSentinel() const noexcept { return type() == NodeType::kSentinel; }
//! Tests whether this node is `FuncNode`.
- inline bool isFunc() const noexcept { return type() == kNodeFunc; }
+ ASMJIT_INLINE_NODEBUG bool isFunc() const noexcept { return type() == NodeType::kFunc; }
//! Tests whether this node is `FuncRetNode`.
- inline bool isFuncRet() const noexcept { return type() == kNodeFuncRet; }
+ ASMJIT_INLINE_NODEBUG bool isFuncRet() const noexcept { return type() == NodeType::kFuncRet; }
//! Tests whether this node is `InvokeNode`.
- inline bool isInvoke() const noexcept { return type() == kNodeInvoke; }
+ ASMJIT_INLINE_NODEBUG bool isInvoke() const noexcept { return type() == NodeType::kInvoke; }
-#ifndef ASMJIT_NO_DEPRECATED
- ASMJIT_DEPRECATED("Use isInvoke")
- inline bool isFuncCall() const noexcept { return isInvoke(); }
-#endif // !ASMJIT_NO_DEPRECATED
-
- //! Returns the node flags, see \ref Flags.
- inline uint32_t flags() const noexcept { return _any._nodeFlags; }
+ //! Returns the node flags.
+ ASMJIT_INLINE_NODEBUG NodeFlags flags() const noexcept { return _any._nodeFlags; }
//! Tests whether the node has the given `flag` set.
- inline bool hasFlag(uint32_t flag) const noexcept { return (uint32_t(_any._nodeFlags) & flag) != 0; }
+ ASMJIT_INLINE_NODEBUG bool hasFlag(NodeFlags flag) const noexcept { return Support::test(_any._nodeFlags, flag); }
//! Replaces node flags with `flags`.
- inline void setFlags(uint32_t flags) noexcept { _any._nodeFlags = uint8_t(flags); }
+ ASMJIT_INLINE_NODEBUG void setFlags(NodeFlags flags) noexcept { _any._nodeFlags = flags; }
//! Adds the given `flags` to node flags.
- inline void addFlags(uint32_t flags) noexcept { _any._nodeFlags = uint8_t(_any._nodeFlags | flags); }
+ ASMJIT_INLINE_NODEBUG void addFlags(NodeFlags flags) noexcept { _any._nodeFlags |= flags; }
//! Clears the given `flags` from node flags.
- inline void clearFlags(uint32_t flags) noexcept { _any._nodeFlags = uint8_t(_any._nodeFlags & (flags ^ 0xFF)); }
+ ASMJIT_INLINE_NODEBUG void clearFlags(NodeFlags flags) noexcept { _any._nodeFlags &= ~flags; }
//! Tests whether the node is code that can be executed.
- inline bool isCode() const noexcept { return hasFlag(kFlagIsCode); }
+ ASMJIT_INLINE_NODEBUG bool isCode() const noexcept { return hasFlag(NodeFlags::kIsCode); }
//! Tests whether the node is data that cannot be executed.
- inline bool isData() const noexcept { return hasFlag(kFlagIsData); }
+ ASMJIT_INLINE_NODEBUG bool isData() const noexcept { return hasFlag(NodeFlags::kIsData); }
//! Tests whether the node is informative only (is never encoded like comment, etc...).
- inline bool isInformative() const noexcept { return hasFlag(kFlagIsInformative); }
+ ASMJIT_INLINE_NODEBUG bool isInformative() const noexcept { return hasFlag(NodeFlags::kIsInformative); }
//! Tests whether the node is removable if it's in an unreachable code block.
- inline bool isRemovable() const noexcept { return hasFlag(kFlagIsRemovable); }
+ ASMJIT_INLINE_NODEBUG bool isRemovable() const noexcept { return hasFlag(NodeFlags::kIsRemovable); }
//! Tests whether the node has no effect when executed (label, .align, nop, ...).
- inline bool hasNoEffect() const noexcept { return hasFlag(kFlagHasNoEffect); }
+ ASMJIT_INLINE_NODEBUG bool hasNoEffect() const noexcept { return hasFlag(NodeFlags::kHasNoEffect); }
//! Tests whether the node is part of the code.
- inline bool isActive() const noexcept { return hasFlag(kFlagIsActive); }
+ ASMJIT_INLINE_NODEBUG bool isActive() const noexcept { return hasFlag(NodeFlags::kIsActive); }
//! Tests whether the node has a position assigned.
//!
//! \remarks Returns `true` if node position is non-zero.
- inline bool hasPosition() const noexcept { return _position != 0; }
+ ASMJIT_INLINE_NODEBUG bool hasPosition() const noexcept { return _position != 0; }
//! Returns node position.
- inline uint32_t position() const noexcept { return _position; }
+ ASMJIT_INLINE_NODEBUG uint32_t position() const noexcept { return _position; }
//! Sets node position.
//!
- //! Node position is a 32-bit unsigned integer that is used by Compiler to
- //! track where the node is relatively to the start of the function. It doesn't
- //! describe a byte position in a binary, instead it's just a pseudo position
+ //! Node position is a 32-bit unsigned integer that is used by Compiler to track where the node is relatively to
+ //! the start of the function. It doesn't describe a byte position in a binary, instead it's just a pseudo position
//! used by liveness analysis and other tools around Compiler.
//!
- //! If you don't use Compiler then you may use `position()` and `setPosition()`
- //! freely for your own purposes if the 32-bit value limit is okay for you.
- inline void setPosition(uint32_t position) noexcept { _position = position; }
+ //! If you don't use Compiler then you may use `position()` and `setPosition()` freely for your own purposes if
+ //! the 32-bit value limit is okay for you.
+ ASMJIT_INLINE_NODEBUG void setPosition(uint32_t position) noexcept { _position = position; }
//! Returns user data casted to `T*`.
//!
- //! User data is decicated to be used only by AsmJit users and not touched
- //! by the library. The data has a pointer size so you can either store a
- //! pointer or `intptr_t` value through `setUserDataAsIntPtr()`.
+ //! User data is dedicated to be used only by AsmJit users and not touched by the library. The data is of a pointer
+ //! size so you can either store a pointer or `int64_t` value through `setUserDataAsPtr()`, `setUserDataAsInt64()`
+ //! and `setUserDataAsUInt64()`.
template<typename T>
- inline T* userDataAsPtr() const noexcept { return static_cast<T*>(_userDataPtr); }
+ ASMJIT_INLINE_NODEBUG T* userDataAsPtr() const noexcept { return static_cast<T*>(_userDataPtr); }
//! Returns user data casted to `int64_t`.
- inline int64_t userDataAsInt64() const noexcept { return int64_t(_userDataU64); }
+ ASMJIT_INLINE_NODEBUG int64_t userDataAsInt64() const noexcept { return int64_t(_userDataU64); }
//! Returns user data casted to `uint64_t`.
- inline uint64_t userDataAsUInt64() const noexcept { return _userDataU64; }
+ ASMJIT_INLINE_NODEBUG uint64_t userDataAsUInt64() const noexcept { return _userDataU64; }
//! Sets user data to `data`.
template<typename T>
- inline void setUserDataAsPtr(T* data) noexcept { _userDataPtr = static_cast<void*>(data); }
+ ASMJIT_INLINE_NODEBUG void setUserDataAsPtr(T* data) noexcept { _userDataPtr = static_cast<void*>(data); }
//! Sets used data to the given 64-bit signed `value`.
- inline void setUserDataAsInt64(int64_t value) noexcept { _userDataU64 = uint64_t(value); }
+ ASMJIT_INLINE_NODEBUG void setUserDataAsInt64(int64_t value) noexcept { _userDataU64 = uint64_t(value); }
//! Sets used data to the given 64-bit unsigned `value`.
- inline void setUserDataAsUInt64(uint64_t value) noexcept { _userDataU64 = value; }
+ ASMJIT_INLINE_NODEBUG void setUserDataAsUInt64(uint64_t value) noexcept { _userDataU64 = value; }
//! Resets user data to zero / nullptr.
- inline void resetUserData() noexcept { _userDataU64 = 0; }
+ ASMJIT_INLINE_NODEBUG void resetUserData() noexcept { _userDataU64 = 0; }
//! Tests whether the node has an associated pass data.
- inline bool hasPassData() const noexcept { return _passData != nullptr; }
+ ASMJIT_INLINE_NODEBUG bool hasPassData() const noexcept { return _passData != nullptr; }
//! Returns the node pass data - data used during processing & transformations.
template<typename T>
- inline T* passData() const noexcept { return (T*)_passData; }
+ ASMJIT_INLINE_NODEBUG T* passData() const noexcept { return (T*)_passData; }
//! Sets the node pass data to `data`.
template<typename T>
- inline void setPassData(T* data) noexcept { _passData = (void*)data; }
+ ASMJIT_INLINE_NODEBUG void setPassData(T* data) noexcept { _passData = (void*)data; }
//! Resets the node pass data to nullptr.
- inline void resetPassData() noexcept { _passData = nullptr; }
+ ASMJIT_INLINE_NODEBUG void resetPassData() noexcept { _passData = nullptr; }
//! Tests whether the node has an inline comment/annotation.
- inline bool hasInlineComment() const noexcept { return _inlineComment != nullptr; }
+ ASMJIT_INLINE_NODEBUG bool hasInlineComment() const noexcept { return _inlineComment != nullptr; }
//! Returns an inline comment/annotation string.
- inline const char* inlineComment() const noexcept { return _inlineComment; }
+ ASMJIT_INLINE_NODEBUG const char* inlineComment() const noexcept { return _inlineComment; }
//! Sets an inline comment/annotation string to `s`.
- inline void setInlineComment(const char* s) noexcept { _inlineComment = s; }
+ ASMJIT_INLINE_NODEBUG void setInlineComment(const char* s) noexcept { _inlineComment = s; }
//! Resets an inline comment/annotation string to nullptr.
- inline void resetInlineComment() noexcept { _inlineComment = nullptr; }
+ ASMJIT_INLINE_NODEBUG void resetInlineComment() noexcept { _inlineComment = nullptr; }
//! \}
};
-// ============================================================================
-// [asmjit::InstNode]
-// ============================================================================
-
//! Instruction node.
//!
//! Wraps an instruction with its options and operands.
@@ -728,25 +746,35 @@ class InstNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(InstNode)
- enum : uint32_t {
- //! Count of embedded operands per `InstNode` that are always allocated as
- //! a part of the instruction. Minimum embedded operands is 4, but in 32-bit
- //! more pointers are smaller and we can embed 5. The rest (up to 6 operands)
- //! is always stored in `InstExNode`.
- kBaseOpCapacity = uint32_t((128 - sizeof(BaseNode) - sizeof(BaseInst)) / sizeof(Operand_))
- };
+ //! \name Constants
+ //! \{
+
+ //! The number of embedded operands for a default \ref InstNode instance that are always allocated as a part of
+ //! the instruction itself. Minimum embedded operands is 4, but in 32-bit more pointers are smaller and we can
+ //! embed 5. The rest (up to 6 operands) is considered extended.
+ //!
+ //! The number of operands InstNode holds is decided when \ref InstNode is created.
+ static constexpr uint32_t kBaseOpCapacity = uint32_t((128 - sizeof(BaseNode) - sizeof(BaseInst)) / sizeof(Operand_));
+
+ //! Count of maximum number of operands \ref InstNode can hold.
+ static constexpr uint32_t kFullOpCapacity = Globals::kMaxOpCount;
+
+ //! \}
+
+ //! \name Members
+ //! \{
//! Base instruction data.
BaseInst _baseInst;
- //! First 4 or 5 operands (indexed from 0).
- Operand_ _opArray[kBaseOpCapacity];
+
+ //! \}
//! \name Construction & Destruction
//! \{
//! Creates a new `InstNode` instance.
- ASMJIT_INLINE InstNode(BaseBuilder* cb, uint32_t instId, uint32_t options, uint32_t opCount, uint32_t opCapacity = kBaseOpCapacity) noexcept
- : BaseNode(cb, kNodeInst, kFlagIsCode | kFlagIsRemovable | kFlagActsAsInst),
+ ASMJIT_INLINE_NODEBUG InstNode(BaseBuilder* cb, InstId instId, InstOptions options, uint32_t opCount, uint32_t opCapacity = kBaseOpCapacity) noexcept
+ : BaseNode(cb, NodeType::kInst, NodeFlags::kIsCode | NodeFlags::kIsRemovable | NodeFlags::kActsAsInst),
_baseInst(instId, options) {
_inst._opCapacity = uint8_t(opCapacity);
_inst._opCount = uint8_t(opCount);
@@ -754,7 +782,7 @@ public:
//! \cond INTERNAL
//! Reset all built-in operands, including `extraReg`.
- inline void _resetOps() noexcept {
+ ASMJIT_INLINE_NODEBUG void _resetOps() noexcept {
_baseInst.resetExtraReg();
resetOpRange(0, opCapacity());
}
@@ -762,80 +790,121 @@ public:
//! \}
- //! \name Accessors
+ //! \name Instruction Object
//! \{
- inline BaseInst& baseInst() noexcept { return _baseInst; }
- inline const BaseInst& baseInst() const noexcept { return _baseInst; }
+ ASMJIT_INLINE_NODEBUG BaseInst& baseInst() noexcept { return _baseInst; }
+ ASMJIT_INLINE_NODEBUG const BaseInst& baseInst() const noexcept { return _baseInst; }
+
+ //! \}
+
+ //! \name Instruction Id
+ //! \{
//! Returns the instruction id, see `BaseInst::Id`.
- inline uint32_t id() const noexcept { return _baseInst.id(); }
+ ASMJIT_INLINE_NODEBUG InstId id() const noexcept { return _baseInst.id(); }
+ //! Returns the instruction real id, see `BaseInst::Id`.
+ ASMJIT_INLINE_NODEBUG InstId realId() const noexcept { return _baseInst.realId(); }
+
//! Sets the instruction id to `id`, see `BaseInst::Id`.
- inline void setId(uint32_t id) noexcept { _baseInst.setId(id); }
+ ASMJIT_INLINE_NODEBUG void setId(InstId id) noexcept { _baseInst.setId(id); }
+
+ //! \}
+
+ //! \name Instruction Options
+ //! \{
- //! Returns instruction options.
- inline uint32_t instOptions() const noexcept { return _baseInst.options(); }
- //! Sets instruction options.
- inline void setInstOptions(uint32_t options) noexcept { _baseInst.setOptions(options); }
- //! Adds instruction options.
- inline void addInstOptions(uint32_t options) noexcept { _baseInst.addOptions(options); }
- //! Clears instruction options.
- inline void clearInstOptions(uint32_t options) noexcept { _baseInst.clearOptions(options); }
+ //! Returns instruction options, see \ref InstOptions for more details.
+ ASMJIT_INLINE_NODEBUG InstOptions options() const noexcept { return _baseInst.options(); }
+ //! Tests whether instruction has the given \option` set/enabled.
+ ASMJIT_INLINE_NODEBUG bool hasOption(InstOptions option) const noexcept { return _baseInst.hasOption(option); }
+ //! Sets instruction `options` to the provided value, resetting all others.
+ ASMJIT_INLINE_NODEBUG void setOptions(InstOptions options) noexcept { _baseInst.setOptions(options); }
+ //! Adds instruction `options` to the instruction.
+ ASMJIT_INLINE_NODEBUG void addOptions(InstOptions options) noexcept { _baseInst.addOptions(options); }
+ //! Clears instruction `options` of the instruction (disables the given options).
+ ASMJIT_INLINE_NODEBUG void clearOptions(InstOptions options) noexcept { _baseInst.clearOptions(options); }
+ //! Resets instruction options to none - disabling all instruction options.
+ ASMJIT_INLINE_NODEBUG void resetOptions() noexcept { _baseInst.resetOptions(); }
+
+ //! \}
+
+ //! \name Extra Register
+ //! \{
//! Tests whether the node has an extra register operand.
- inline bool hasExtraReg() const noexcept { return _baseInst.hasExtraReg(); }
+ ASMJIT_INLINE_NODEBUG bool hasExtraReg() const noexcept { return _baseInst.hasExtraReg(); }
//! Returns extra register operand.
- inline RegOnly& extraReg() noexcept { return _baseInst.extraReg(); }
+ ASMJIT_INLINE_NODEBUG RegOnly& extraReg() noexcept { return _baseInst.extraReg(); }
//! \overload
- inline const RegOnly& extraReg() const noexcept { return _baseInst.extraReg(); }
+ ASMJIT_INLINE_NODEBUG const RegOnly& extraReg() const noexcept { return _baseInst.extraReg(); }
//! Sets extra register operand to `reg`.
- inline void setExtraReg(const BaseReg& reg) noexcept { _baseInst.setExtraReg(reg); }
+ ASMJIT_INLINE_NODEBUG void setExtraReg(const BaseReg& reg) noexcept { _baseInst.setExtraReg(reg); }
//! Sets extra register operand to `reg`.
- inline void setExtraReg(const RegOnly& reg) noexcept { _baseInst.setExtraReg(reg); }
+ ASMJIT_INLINE_NODEBUG void setExtraReg(const RegOnly& reg) noexcept { _baseInst.setExtraReg(reg); }
//! Resets extra register operand.
- inline void resetExtraReg() noexcept { _baseInst.resetExtraReg(); }
+ ASMJIT_INLINE_NODEBUG void resetExtraReg() noexcept { _baseInst.resetExtraReg(); }
+
+ //! \}
+
+ //! \name Instruction Operands
+ //! \{
//! Returns operand count.
- inline uint32_t opCount() const noexcept { return _inst._opCount; }
+ ASMJIT_INLINE_NODEBUG uint32_t opCount() const noexcept { return _inst._opCount; }
//! Returns operand capacity.
- inline uint32_t opCapacity() const noexcept { return _inst._opCapacity; }
+ ASMJIT_INLINE_NODEBUG uint32_t opCapacity() const noexcept { return _inst._opCapacity; }
//! Sets operand count.
- inline void setOpCount(uint32_t opCount) noexcept { _inst._opCount = uint8_t(opCount); }
+ ASMJIT_INLINE_NODEBUG void setOpCount(uint32_t opCount) noexcept { _inst._opCount = uint8_t(opCount); }
//! Returns operands array.
- inline Operand* operands() noexcept { return (Operand*)_opArray; }
+ ASMJIT_INLINE_NODEBUG Operand* operands() noexcept {
+ return reinterpret_cast<Operand*>(reinterpret_cast<uint8_t*>(this) + sizeof(InstNode));
+ }
+
//! Returns operands array (const).
- inline const Operand* operands() const noexcept { return (const Operand*)_opArray; }
+ ASMJIT_INLINE_NODEBUG const Operand* operands() const noexcept {
+ return reinterpret_cast<const Operand*>(reinterpret_cast<const uint8_t*>(this) + sizeof(InstNode));
+ }
//! Returns operand at the given `index`.
inline Operand& op(uint32_t index) noexcept {
ASMJIT_ASSERT(index < opCapacity());
- return _opArray[index].as<Operand>();
+
+ Operand* ops = operands();
+ return ops[index].as<Operand>();
}
//! Returns operand at the given `index` (const).
inline const Operand& op(uint32_t index) const noexcept {
ASMJIT_ASSERT(index < opCapacity());
- return _opArray[index].as<Operand>();
+
+ const Operand* ops = operands();
+ return ops[index].as<Operand>();
}
//! Sets operand at the given `index` to `op`.
inline void setOp(uint32_t index, const Operand_& op) noexcept {
ASMJIT_ASSERT(index < opCapacity());
- _opArray[index].copyFrom(op);
+
+ Operand* ops = operands();
+ ops[index].copyFrom(op);
}
//! Resets operand at the given `index` to none.
inline void resetOp(uint32_t index) noexcept {
ASMJIT_ASSERT(index < opCapacity());
- _opArray[index].reset();
+
+ Operand* ops = operands();
+ ops[index].reset();
}
//! Resets operands at `[start, end)` range.
inline void resetOpRange(uint32_t start, uint32_t end) noexcept {
+ Operand* ops = operands();
for (uint32_t i = start; i < end; i++)
- _opArray[i].reset();
+ ops[i].reset();
}
//! \}
@@ -843,34 +912,48 @@ public:
//! \name Utilities
//! \{
- inline bool hasOpType(uint32_t opType) const noexcept {
+ //! Tests whether the given operand type `opType` is used by the instruction.
+ inline bool hasOpType(OperandType opType) const noexcept {
+ const Operand* ops = operands();
for (uint32_t i = 0, count = opCount(); i < count; i++)
- if (_opArray[i].opType() == opType)
+ if (ops[i].opType() == opType)
return true;
return false;
}
- inline bool hasRegOp() const noexcept { return hasOpType(Operand::kOpReg); }
- inline bool hasMemOp() const noexcept { return hasOpType(Operand::kOpMem); }
- inline bool hasImmOp() const noexcept { return hasOpType(Operand::kOpImm); }
- inline bool hasLabelOp() const noexcept { return hasOpType(Operand::kOpLabel); }
+ //! Tests whether the instruction uses at least one register operand.
+ inline bool hasRegOp() const noexcept { return hasOpType(OperandType::kReg); }
+ //! Tests whether the instruction uses at least one memory operand.
+ inline bool hasMemOp() const noexcept { return hasOpType(OperandType::kMem); }
+ //! Tests whether the instruction uses at least one immediate operand.
+ inline bool hasImmOp() const noexcept { return hasOpType(OperandType::kImm); }
+ //! Tests whether the instruction uses at least one label operand.
+ inline bool hasLabelOp() const noexcept { return hasOpType(OperandType::kLabel); }
- inline uint32_t indexOfOpType(uint32_t opType) const noexcept {
+ //! Returns the index of the given operand type `opType`.
+ //!
+ //! \note If the operand type wa found, the value returned represents its index in \ref operands()
+ //! array, otherwise \ref Globals::kNotFound is returned to signalize that the operand was not found.
+ inline uint32_t indexOfOpType(OperandType opType) const noexcept {
uint32_t i = 0;
uint32_t count = opCount();
+ const Operand* ops = operands();
while (i < count) {
- if (_opArray[i].opType() == opType)
- break;
+ if (ops[i].opType() == opType)
+ return i;
i++;
}
- return i;
+ return Globals::kNotFound;
}
- inline uint32_t indexOfMemOp() const noexcept { return indexOfOpType(Operand::kOpMem); }
- inline uint32_t indexOfImmOp() const noexcept { return indexOfOpType(Operand::kOpImm); }
- inline uint32_t indexOfLabelOp() const noexcept { return indexOfOpType(Operand::kOpLabel); }
+ //! A shortcut that calls `indexOfOpType(OperandType::kMem)`.
+ inline uint32_t indexOfMemOp() const noexcept { return indexOfOpType(OperandType::kMem); }
+ //! A shortcut that calls `indexOfOpType(OperandType::kImm)`.
+ inline uint32_t indexOfImmOp() const noexcept { return indexOfOpType(OperandType::kImm); }
+ //! A shortcut that calls `indexOfOpType(OperandType::kLabel)`.
+ inline uint32_t indexOfLabelOp() const noexcept { return indexOfOpType(OperandType::kLabel); }
//! \}
@@ -878,20 +961,40 @@ public:
//! \{
//! \cond INTERNAL
- inline uint32_t* _getRewriteArray() noexcept { return &_baseInst._extraReg._id; }
- inline const uint32_t* _getRewriteArray() const noexcept { return &_baseInst._extraReg._id; }
- ASMJIT_INLINE uint32_t getRewriteIndex(const uint32_t* id) const noexcept {
+ //! Returns uint32_t[] view that represents BaseInst::RegOnly and instruction operands.
+ ASMJIT_INLINE_NODEBUG uint32_t* _getRewriteArray() noexcept { return &_baseInst._extraReg._id; }
+ //! \overload
+ ASMJIT_INLINE_NODEBUG const uint32_t* _getRewriteArray() const noexcept { return &_baseInst._extraReg._id; }
+
+ //! Maximum value of rewrite id - 6 operands each having 4 slots is 24, one RegOnly having 2 slots => 26.
+ static constexpr uint32_t kMaxRewriteId = 26 - 1;
+
+ //! Returns a rewrite index of the given pointer to `id`.
+ //!
+ //! This function returns a value that can be then passed to `\ref rewriteIdAtIndex() function. It can address
+ //! any id from any operand that is used by the instruction in addition to \ref BaseInst::regOnly field, which
+ //! can also be used by the register allocator.
+ inline uint32_t getRewriteIndex(const uint32_t* id) const noexcept {
const uint32_t* array = _getRewriteArray();
ASMJIT_ASSERT(array <= id);
size_t index = (size_t)(id - array);
- ASMJIT_ASSERT(index < 32);
+ ASMJIT_ASSERT(index <= kMaxRewriteId);
return uint32_t(index);
}
- ASMJIT_INLINE void rewriteIdAtIndex(uint32_t index, uint32_t id) noexcept {
+ //! Rewrites the given `index` to the provided identifier `id`.
+ //!
+ //! \note This is an internal function that is used by a \ref BaseCompiler implementation to rewrite virtual
+ //! registers to physical registers. The rewriter in this case sees all operands as array of uint32 values
+ //! and the given `index` describes a position in this array. For example a single \ref Operand would be
+ //! decomposed to 4 uint32_t values, where the first at index 0 would be operand signature, next would be
+ //! base id, etc... This is a comfortable way of patching operands without having to check for their types.
+ inline void rewriteIdAtIndex(uint32_t index, uint32_t id) noexcept {
+ ASMJIT_ASSERT(index <= kMaxRewriteId);
+
uint32_t* array = _getRewriteArray();
array[index] = id;
}
@@ -903,71 +1006,69 @@ public:
//! \{
//! \cond INTERNAL
- static inline uint32_t capacityOfOpCount(uint32_t opCount) noexcept {
- return opCount <= kBaseOpCapacity ? kBaseOpCapacity : Globals::kMaxOpCount;
+
+ //! Returns the capacity required for the given operands count `opCount`.
+ //!
+ //! There are only two capacities used - \ref kBaseOpCapacity and \ref kFullOpCapacity, so this function
+ //! is used to decide between these two. The general rule is that instructions that can be represented with
+ //! \ref kBaseOpCapacity would use this value, and all others would take \ref kFullOpCapacity.
+ static ASMJIT_INLINE_NODEBUG constexpr uint32_t capacityOfOpCount(uint32_t opCount) noexcept {
+ return opCount <= kBaseOpCapacity ? kBaseOpCapacity : kFullOpCapacity;
}
- static inline size_t nodeSizeOfOpCapacity(uint32_t opCapacity) noexcept {
- size_t base = sizeof(InstNode) - kBaseOpCapacity * sizeof(Operand);
- return base + opCapacity * sizeof(Operand);
+ //! Calculates the size of \ref InstNode required to hold at most `opCapacity` operands.
+ //!
+ //! This function is used internally to allocate \ref InstNode.
+ static ASMJIT_INLINE_NODEBUG constexpr size_t nodeSizeOfOpCapacity(uint32_t opCapacity) noexcept {
+ return sizeof(InstNode) + opCapacity * sizeof(Operand);
}
//! \endcond
//! \}
};
-// ============================================================================
-// [asmjit::InstExNode]
-// ============================================================================
-
-//! Instruction node with maximum number of operands.
+//! Instruction node with embedded operands following \ref InstNode layout.
//!
-//! This node is created automatically by Builder/Compiler in case that the
-//! required number of operands exceeds the default capacity of `InstNode`.
-class InstExNode : public InstNode {
+//! \note This is used to make tools such as static analysis and compilers happy about the layout. There were two
+//! instruction nodes in the past, having the second extend the operand array of the first, but that has caused
+//! undefined behavior and made recent tools unhappy about that.
+template<uint32_t kN>
+class InstNodeWithOperands : public InstNode {
public:
- ASMJIT_NONCOPYABLE(InstExNode)
-
- //! Continued `_opArray[]` to hold up to `kMaxOpCount` operands.
- Operand_ _opArrayEx[Globals::kMaxOpCount - kBaseOpCapacity];
+ Operand_ _operands[kN];
- //! \name Construction & Destruction
- //! \{
-
- //! Creates a new `InstExNode` instance.
- inline InstExNode(BaseBuilder* cb, uint32_t instId, uint32_t options, uint32_t opCapacity = Globals::kMaxOpCount) noexcept
- : InstNode(cb, instId, options, opCapacity) {}
-
- //! \}
+ //! Creates a new `InstNodeWithOperands` instance.
+ ASMJIT_INLINE_NODEBUG InstNodeWithOperands(BaseBuilder* cb, InstId instId, InstOptions options, uint32_t opCount) noexcept
+ : InstNode(cb, instId, options, opCount, kN) {}
};
-// ============================================================================
-// [asmjit::SectionNode]
-// ============================================================================
-
//! Section node.
class SectionNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(SectionNode)
+ //! \name Members
+ //! \{
+
//! Section id.
uint32_t _id;
//! Next section node that follows this section.
//!
- //! This link is only valid when the section is active (is part of the code)
- //! and when `Builder::hasDirtySectionLinks()` returns `false`. If you intend
- //! to use this field you should always call `Builder::updateSectionLinks()`
- //! before you do so.
+ //! This link is only valid when the section is active (is part of the code) and when `Builder::hasDirtySectionLinks()`
+ //! returns `false`. If you intend to use this field you should always call `Builder::updateSectionLinks()` before you
+ //! do so.
SectionNode* _nextSection;
+ //! \}
+
//! \name Construction & Destruction
//! \{
//! Creates a new `SectionNode` instance.
- inline SectionNode(BaseBuilder* cb, uint32_t id = 0) noexcept
- : BaseNode(cb, kNodeSection, kFlagHasNoEffect),
- _id(id),
+ ASMJIT_INLINE_NODEBUG SectionNode(BaseBuilder* cb, uint32_t sectionId = 0) noexcept
+ : BaseNode(cb, NodeType::kSection, NodeFlags::kHasNoEffect),
+ _id(sectionId),
_nextSection(nullptr) {}
//! \}
@@ -976,29 +1077,30 @@ public:
//! \{
//! Returns the section id.
- inline uint32_t id() const noexcept { return _id; }
+ ASMJIT_INLINE_NODEBUG uint32_t id() const noexcept { return _id; }
//! \}
};
-// ============================================================================
-// [asmjit::LabelNode]
-// ============================================================================
-
//! Label node.
class LabelNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(LabelNode)
+ //! \name Members
+ //! \{
+
//! Label identifier.
uint32_t _labelId;
+ //! \}
+
//! \name Construction & Destruction
//! \{
//! Creates a new `LabelNode` instance.
- inline LabelNode(BaseBuilder* cb, uint32_t labelId = 0) noexcept
- : BaseNode(cb, kNodeLabel, kFlagHasNoEffect | kFlagActsAsLabel),
+ ASMJIT_INLINE_NODEBUG LabelNode(BaseBuilder* cb, uint32_t labelId = 0) noexcept
+ : BaseNode(cb, NodeType::kLabel, NodeFlags::kHasNoEffect | NodeFlags::kActsAsLabel),
_labelId(labelId) {}
//! \}
@@ -1007,22 +1109,13 @@ public:
//! \{
//! Returns \ref Label representation of the \ref LabelNode.
- inline Label label() const noexcept { return Label(_labelId); }
+ ASMJIT_INLINE_NODEBUG Label label() const noexcept { return Label(_labelId); }
//! Returns the id of the label.
- inline uint32_t labelId() const noexcept { return _labelId; }
+ ASMJIT_INLINE_NODEBUG uint32_t labelId() const noexcept { return _labelId; }
//! \}
-
-#ifndef ASMJIT_NO_DEPRECATED
- ASMJIT_DEPRECATED("Use labelId() instead")
- inline uint32_t id() const noexcept { return labelId(); }
-#endif // !ASMJIT_NO_DEPRECATED
};
-// ============================================================================
-// [asmjit::AlignNode]
-// ============================================================================
-
//! Align directive (BaseBuilder).
//!
//! Wraps `.align` directive.
@@ -1030,19 +1123,24 @@ class AlignNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(AlignNode)
- //! Align mode, see `AlignMode`.
- uint32_t _alignMode;
+ //! \name Members
+ //! \{
+
//! Alignment (in bytes).
uint32_t _alignment;
+ //! \}
+
//! \name Construction & Destruction
//! \{
//! Creates a new `AlignNode` instance.
- inline AlignNode(BaseBuilder* cb, uint32_t alignMode, uint32_t alignment) noexcept
- : BaseNode(cb, kNodeAlign, kFlagIsCode | kFlagHasNoEffect),
- _alignMode(alignMode),
- _alignment(alignment) {}
+ ASMJIT_INLINE_NODEBUG AlignNode(BaseBuilder* cb, AlignMode alignMode, uint32_t alignment) noexcept
+ : BaseNode(cb, NodeType::kAlign, NodeFlags::kIsCode | NodeFlags::kHasNoEffect) {
+
+ _alignData._alignMode = alignMode;
+ _alignment = alignment;
+ }
//! \}
@@ -1050,34 +1148,34 @@ public:
//! \{
//! Returns align mode.
- inline uint32_t alignMode() const noexcept { return _alignMode; }
+ ASMJIT_INLINE_NODEBUG AlignMode alignMode() const noexcept { return _alignData._alignMode; }
//! Sets align mode to `alignMode`.
- inline void setAlignMode(uint32_t alignMode) noexcept { _alignMode = alignMode; }
+ ASMJIT_INLINE_NODEBUG void setAlignMode(AlignMode alignMode) noexcept { _alignData._alignMode = alignMode; }
//! Returns align offset in bytes.
- inline uint32_t alignment() const noexcept { return _alignment; }
+ ASMJIT_INLINE_NODEBUG uint32_t alignment() const noexcept { return _alignment; }
//! Sets align offset in bytes to `offset`.
- inline void setAlignment(uint32_t alignment) noexcept { _alignment = alignment; }
+ ASMJIT_INLINE_NODEBUG void setAlignment(uint32_t alignment) noexcept { _alignment = alignment; }
//! \}
};
-// ============================================================================
-// [asmjit::EmbedDataNode]
-// ============================================================================
-
//! Embed data node.
//!
-//! Wraps `.data` directive. The node contains data that will be placed at the
-//! node's position in the assembler stream. The data is considered to be RAW;
-//! no analysis nor byte-order conversion is performed on RAW data.
+//! Wraps `.data` directive. The node contains data that will be placed at the node's position in the assembler
+//! stream. The data is considered to be RAW; no analysis nor byte-order conversion is performed on RAW data.
class EmbedDataNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(EmbedDataNode)
+ //! \cond INTERNAL
enum : uint32_t {
kInlineBufferSize = 128 - (sizeof(BaseNode) + sizeof(size_t) * 2)
};
+ //! \endcond
+
+ //! \name Members
+ //! \{
size_t _itemCount;
size_t _repeatCount;
@@ -1087,15 +1185,17 @@ public:
uint8_t _inlineData[kInlineBufferSize];
};
+ //! \}
+
//! \name Construction & Destruction
//! \{
//! Creates a new `EmbedDataNode` instance.
- inline EmbedDataNode(BaseBuilder* cb) noexcept
- : BaseNode(cb, kNodeEmbedData, kFlagIsData),
+ ASMJIT_INLINE_NODEBUG EmbedDataNode(BaseBuilder* cb) noexcept
+ : BaseNode(cb, NodeType::kEmbedData, NodeFlags::kIsData),
_itemCount(0),
_repeatCount(0) {
- _embed._typeId = uint8_t(Type::kIdU8),
+ _embed._typeId = TypeId::kUInt8;
_embed._typeSize = uint8_t(1);
memset(_inlineData, 0, kInlineBufferSize);
}
@@ -1105,54 +1205,57 @@ public:
//! \name Accessors
//! \{
- //! Returns \ref Type::Id of the data.
- inline uint32_t typeId() const noexcept { return _embed._typeId; }
+ //! Returns data type as \ref TypeId.
+ ASMJIT_INLINE_NODEBUG TypeId typeId() const noexcept { return _embed._typeId; }
//! Returns the size of a single data element.
- inline uint32_t typeSize() const noexcept { return _embed._typeSize; }
+ ASMJIT_INLINE_NODEBUG uint32_t typeSize() const noexcept { return _embed._typeSize; }
//! Returns a pointer to the data casted to `uint8_t`.
- inline uint8_t* data() const noexcept {
+ ASMJIT_INLINE_NODEBUG uint8_t* data() const noexcept {
return dataSize() <= kInlineBufferSize ? const_cast<uint8_t*>(_inlineData) : _externalData;
}
//! Returns a pointer to the data casted to `T`.
template<typename T>
- inline T* dataAs() const noexcept { return reinterpret_cast<T*>(data()); }
+ ASMJIT_INLINE_NODEBUG T* dataAs() const noexcept { return reinterpret_cast<T*>(data()); }
//! Returns the number of (typed) items in the array.
- inline size_t itemCount() const noexcept { return _itemCount; }
+ ASMJIT_INLINE_NODEBUG size_t itemCount() const noexcept { return _itemCount; }
//! Returns how many times the data is repeated (default 1).
//!
//! Repeated data is useful when defining constants for SIMD, for example.
- inline size_t repeatCount() const noexcept { return _repeatCount; }
+ ASMJIT_INLINE_NODEBUG size_t repeatCount() const noexcept { return _repeatCount; }
//! Returns the size of the data, not considering the number of times it repeats.
//!
//! \note The returned value is the same as `typeSize() * itemCount()`.
- inline size_t dataSize() const noexcept { return typeSize() * _itemCount; }
+ ASMJIT_INLINE_NODEBUG size_t dataSize() const noexcept { return typeSize() * _itemCount; }
//! \}
};
-// ============================================================================
-// [asmjit::EmbedLabelNode]
-// ============================================================================
-
//! Label data node.
class EmbedLabelNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(EmbedLabelNode)
+ //! \name Members
+ //! \{
+
uint32_t _labelId;
+ uint32_t _dataSize;
+
+ //! \}
//! \name Construction & Destruction
//! \{
//! Creates a new `EmbedLabelNode` instance.
- inline EmbedLabelNode(BaseBuilder* cb, uint32_t labelId = 0) noexcept
- : BaseNode(cb, kNodeEmbedLabel, kFlagIsData),
- _labelId(labelId) {}
+ ASMJIT_INLINE_NODEBUG EmbedLabelNode(BaseBuilder* cb, uint32_t labelId = 0, uint32_t dataSize = 0) noexcept
+ : BaseNode(cb, NodeType::kEmbedLabel, NodeFlags::kIsData),
+ _labelId(labelId),
+ _dataSize(dataSize) {}
//! \}
@@ -1160,42 +1263,43 @@ public:
//! \{
//! Returns the label to embed as \ref Label operand.
- inline Label label() const noexcept { return Label(_labelId); }
+ ASMJIT_INLINE_NODEBUG Label label() const noexcept { return Label(_labelId); }
//! Returns the id of the label.
- inline uint32_t labelId() const noexcept { return _labelId; }
+ ASMJIT_INLINE_NODEBUG uint32_t labelId() const noexcept { return _labelId; }
//! Sets the label id from `label` operand.
- inline void setLabel(const Label& label) noexcept { setLabelId(label.id()); }
+ ASMJIT_INLINE_NODEBUG void setLabel(const Label& label) noexcept { setLabelId(label.id()); }
//! Sets the label id (use with caution, improper use can break a lot of things).
- inline void setLabelId(uint32_t labelId) noexcept { _labelId = labelId; }
+ ASMJIT_INLINE_NODEBUG void setLabelId(uint32_t labelId) noexcept { _labelId = labelId; }
- //! \}
+ //! Returns the data size.
+ ASMJIT_INLINE_NODEBUG uint32_t dataSize() const noexcept { return _dataSize; }
+ //! Sets the data size.
+ ASMJIT_INLINE_NODEBUG void setDataSize(uint32_t dataSize) noexcept { _dataSize = dataSize; }
-#ifndef ASMJIT_NO_DEPRECATED
- ASMJIT_DEPRECATED("Use labelId() instead")
- inline uint32_t id() const noexcept { return labelId(); }
-#endif // !ASMJIT_NO_DEPRECATED
+ //! \}
};
-// ============================================================================
-// [asmjit::EmbedLabelDeltaNode]
-// ============================================================================
-
//! Label data node.
class EmbedLabelDeltaNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(EmbedLabelDeltaNode)
+ //! \name Members
+ //! \{
+
uint32_t _labelId;
uint32_t _baseLabelId;
uint32_t _dataSize;
+ //! \}
+
//! \name Construction & Destruction
//! \{
//! Creates a new `EmbedLabelDeltaNode` instance.
- inline EmbedLabelDeltaNode(BaseBuilder* cb, uint32_t labelId = 0, uint32_t baseLabelId = 0, uint32_t dataSize = 0) noexcept
- : BaseNode(cb, kNodeEmbedLabelDelta, kFlagIsData),
+ ASMJIT_INLINE_NODEBUG EmbedLabelDeltaNode(BaseBuilder* cb, uint32_t labelId = 0, uint32_t baseLabelId = 0, uint32_t dataSize = 0) noexcept
+ : BaseNode(cb, NodeType::kEmbedLabelDelta, NodeFlags::kIsData),
_labelId(labelId),
_baseLabelId(baseLabelId),
_dataSize(dataSize) {}
@@ -1206,69 +1310,56 @@ public:
//! \{
//! Returns the label as `Label` operand.
- inline Label label() const noexcept { return Label(_labelId); }
+ ASMJIT_INLINE_NODEBUG Label label() const noexcept { return Label(_labelId); }
//! Returns the id of the label.
- inline uint32_t labelId() const noexcept { return _labelId; }
+ ASMJIT_INLINE_NODEBUG uint32_t labelId() const noexcept { return _labelId; }
//! Sets the label id from `label` operand.
- inline void setLabel(const Label& label) noexcept { setLabelId(label.id()); }
+ ASMJIT_INLINE_NODEBUG void setLabel(const Label& label) noexcept { setLabelId(label.id()); }
//! Sets the label id.
- inline void setLabelId(uint32_t labelId) noexcept { _labelId = labelId; }
+ ASMJIT_INLINE_NODEBUG void setLabelId(uint32_t labelId) noexcept { _labelId = labelId; }
//! Returns the base label as `Label` operand.
- inline Label baseLabel() const noexcept { return Label(_baseLabelId); }
+ ASMJIT_INLINE_NODEBUG Label baseLabel() const noexcept { return Label(_baseLabelId); }
//! Returns the id of the base label.
- inline uint32_t baseLabelId() const noexcept { return _baseLabelId; }
+ ASMJIT_INLINE_NODEBUG uint32_t baseLabelId() const noexcept { return _baseLabelId; }
//! Sets the base label id from `label` operand.
- inline void setBaseLabel(const Label& baseLabel) noexcept { setBaseLabelId(baseLabel.id()); }
+ ASMJIT_INLINE_NODEBUG void setBaseLabel(const Label& baseLabel) noexcept { setBaseLabelId(baseLabel.id()); }
//! Sets the base label id.
- inline void setBaseLabelId(uint32_t baseLabelId) noexcept { _baseLabelId = baseLabelId; }
+ ASMJIT_INLINE_NODEBUG void setBaseLabelId(uint32_t baseLabelId) noexcept { _baseLabelId = baseLabelId; }
//! Returns the size of the embedded label address.
- inline uint32_t dataSize() const noexcept { return _dataSize; }
+ ASMJIT_INLINE_NODEBUG uint32_t dataSize() const noexcept { return _dataSize; }
//! Sets the size of the embedded label address.
- inline void setDataSize(uint32_t dataSize) noexcept { _dataSize = dataSize; }
+ ASMJIT_INLINE_NODEBUG void setDataSize(uint32_t dataSize) noexcept { _dataSize = dataSize; }
//! \}
-
-#ifndef ASMJIT_NO_DEPRECATED
- ASMJIT_DEPRECATED("Use labelId() instead")
- inline uint32_t id() const noexcept { return labelId(); }
-
- ASMJIT_DEPRECATED("Use setLabelId() instead")
- inline void setId(uint32_t id) noexcept { setLabelId(id); }
-
- ASMJIT_DEPRECATED("Use baseLabelId() instead")
- inline uint32_t baseId() const noexcept { return baseLabelId(); }
-
- ASMJIT_DEPRECATED("Use setBaseLabelId() instead")
- inline void setBaseId(uint32_t id) noexcept { setBaseLabelId(id); }
-#endif // !ASMJIT_NO_DEPRECATED
};
-// ============================================================================
-// [asmjit::ConstPoolNode]
-// ============================================================================
-
//! A node that wraps `ConstPool`.
class ConstPoolNode : public LabelNode {
public:
ASMJIT_NONCOPYABLE(ConstPoolNode)
+ //! \name Members
+ //! \{
+
ConstPool _constPool;
+ //! \}
+
//! \name Construction & Destruction
//! \{
//! Creates a new `ConstPoolNode` instance.
- inline ConstPoolNode(BaseBuilder* cb, uint32_t id = 0) noexcept
+ ASMJIT_INLINE_NODEBUG ConstPoolNode(BaseBuilder* cb, uint32_t id = 0) noexcept
: LabelNode(cb, id),
_constPool(&cb->_codeZone) {
- setType(kNodeConstPool);
- addFlags(kFlagIsData);
- clearFlags(kFlagIsCode | kFlagHasNoEffect);
+ setType(NodeType::kConstPool);
+ addFlags(NodeFlags::kIsData);
+ clearFlags(NodeFlags::kIsCode | NodeFlags::kHasNoEffect);
}
//! \}
@@ -1277,16 +1368,16 @@ public:
//! \{
//! Tests whether the constant-pool is empty.
- inline bool empty() const noexcept { return _constPool.empty(); }
+ ASMJIT_INLINE_NODEBUG bool empty() const noexcept { return _constPool.empty(); }
//! Returns the size of the constant-pool in bytes.
- inline size_t size() const noexcept { return _constPool.size(); }
+ ASMJIT_INLINE_NODEBUG size_t size() const noexcept { return _constPool.size(); }
//! Returns minimum alignment.
- inline size_t alignment() const noexcept { return _constPool.alignment(); }
+ ASMJIT_INLINE_NODEBUG size_t alignment() const noexcept { return _constPool.alignment(); }
//! Returns the wrapped `ConstPool` instance.
- inline ConstPool& constPool() noexcept { return _constPool; }
+ ASMJIT_INLINE_NODEBUG ConstPool& constPool() noexcept { return _constPool; }
//! Returns the wrapped `ConstPool` instance (const).
- inline const ConstPool& constPool() const noexcept { return _constPool; }
+ ASMJIT_INLINE_NODEBUG const ConstPool& constPool() const noexcept { return _constPool; }
//! \}
@@ -1294,17 +1385,13 @@ public:
//! \{
//! See `ConstPool::add()`.
- inline Error add(const void* data, size_t size, size_t& dstOffset) noexcept {
+ ASMJIT_INLINE_NODEBUG Error add(const void* data, size_t size, size_t& dstOffset) noexcept {
return _constPool.add(data, size, dstOffset);
}
//! \}
};
-// ============================================================================
-// [asmjit::CommentNode]
-// ============================================================================
-
//! Comment node.
class CommentNode : public BaseNode {
public:
@@ -1314,42 +1401,30 @@ public:
//! \{
//! Creates a new `CommentNode` instance.
- inline CommentNode(BaseBuilder* cb, const char* comment) noexcept
- : BaseNode(cb, kNodeComment, kFlagIsInformative | kFlagHasNoEffect | kFlagIsRemovable) {
+ ASMJIT_INLINE_NODEBUG CommentNode(BaseBuilder* cb, const char* comment) noexcept
+ : BaseNode(cb, NodeType::kComment, NodeFlags::kIsInformative | NodeFlags::kHasNoEffect | NodeFlags::kIsRemovable) {
_inlineComment = comment;
}
//! \}
};
-// ============================================================================
-// [asmjit::SentinelNode]
-// ============================================================================
-
//! Sentinel node.
//!
-//! Sentinel is a marker that is completely ignored by the code builder. It's
-//! used to remember a position in a code as it never gets removed by any pass.
+//! Sentinel is a marker that is completely ignored by the code builder. It's used to remember a position in a code
+//! as it never gets removed by any pass.
class SentinelNode : public BaseNode {
public:
ASMJIT_NONCOPYABLE(SentinelNode)
- //! Type of the sentinel (purery informative purpose).
- enum SentinelType : uint32_t {
- //! Type of the sentinel is not known.
- kSentinelUnknown = 0u,
- //! This is a sentinel used at the end of \ref FuncNode.
- kSentinelFuncEnd = 1u
- };
-
//! \name Construction & Destruction
//! \{
//! Creates a new `SentinelNode` instance.
- inline SentinelNode(BaseBuilder* cb, uint32_t sentinelType = kSentinelUnknown) noexcept
- : BaseNode(cb, kNodeSentinel, kFlagIsInformative | kFlagHasNoEffect) {
+ ASMJIT_INLINE_NODEBUG SentinelNode(BaseBuilder* cb, SentinelType sentinelType = SentinelType::kUnknown) noexcept
+ : BaseNode(cb, NodeType::kSentinel, NodeFlags::kIsInformative | NodeFlags::kHasNoEffect) {
- _sentinel._sentinelType = uint8_t(sentinelType);
+ _sentinel._sentinelType = sentinelType;
}
//! \}
@@ -1358,32 +1433,33 @@ public:
//! \{
//! Returns the type of the sentinel.
- inline uint32_t sentinelType() const noexcept {
+ ASMJIT_INLINE_NODEBUG SentinelType sentinelType() const noexcept {
return _sentinel._sentinelType;
}
//! Sets the type of the sentinel.
- inline void setSentinelType(uint32_t type) noexcept {
- _sentinel._sentinelType = uint8_t(type);
+ ASMJIT_INLINE_NODEBUG void setSentinelType(SentinelType type) noexcept {
+ _sentinel._sentinelType = type;
}
//! \}
};
-// ============================================================================
-// [asmjit::Pass]
-// ============================================================================
-
//! Pass can be used to implement code transformations, analysis, and lowering.
class ASMJIT_VIRTAPI Pass {
public:
ASMJIT_BASE_CLASS(Pass)
ASMJIT_NONCOPYABLE(Pass)
+ //! \name Members
+ //! \{
+
//! BaseBuilder this pass is assigned to.
- BaseBuilder* _cb;
+ BaseBuilder* _cb = nullptr;
//! Name of the pass.
- const char* _name;
+ const char* _name = nullptr;
+
+ //! \}
//! \name Construction & Destruction
//! \{
@@ -1397,9 +1473,9 @@ public:
//! \{
//! Returns \ref BaseBuilder associated with the pass.
- inline const BaseBuilder* cb() const noexcept { return _cb; }
+ ASMJIT_INLINE_NODEBUG const BaseBuilder* cb() const noexcept { return _cb; }
//! Returns the name of the pass.
- inline const char* name() const noexcept { return _name; }
+ ASMJIT_INLINE_NODEBUG const char* name() const noexcept { return _name; }
//! \}
@@ -1408,9 +1484,9 @@ public:
//! Processes the code stored in Builder or Compiler.
//!
- //! This is the only function that is called by the `BaseBuilder` to process
- //! the code. It passes `zone`, which will be reset after the `run()` finishes.
- virtual Error run(Zone* zone, Logger* logger) = 0;
+ //! This is the only function that is called by the `BaseBuilder` to process the code. It passes `zone`,
+ //! which will be reset after the `run()` finishes.
+ ASMJIT_API virtual Error run(Zone* zone, Logger* logger);
//! \}
};