LLVM 19.0.0git
RuntimeDyldChecker.h
Go to the documentation of this file.
1//===---- RuntimeDyldChecker.h - RuntimeDyld tester framework -----*- C++ -*-=//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_EXECUTIONENGINE_RUNTIMEDYLDCHECKER_H
10#define LLVM_EXECUTIONENGINE_RUNTIMEDYLDCHECKER_H
11
13#include "llvm/Support/Endian.h"
16#include <optional>
17
18#include <cstdint>
19#include <memory>
20#include <string>
21#include <utility>
22
23namespace llvm {
24
25class StringRef;
26class MCDisassembler;
27class MemoryBuffer;
28class MCInstPrinter;
29class RuntimeDyld;
30class RuntimeDyldCheckerImpl;
31class raw_ostream;
32
33/// Holds target-specific properties for a symbol.
34using TargetFlagsType = uint8_t;
35
36/// RuntimeDyld invariant checker for verifying that RuntimeDyld has
37/// correctly applied relocations.
38///
39/// The RuntimeDyldChecker class evaluates expressions against an attached
40/// RuntimeDyld instance to verify that relocations have been applied
41/// correctly.
42///
43/// The expression language supports basic pointer arithmetic and bit-masking,
44/// and has limited disassembler integration for accessing instruction
45/// operands and the next PC (program counter) address for each instruction.
46///
47/// The language syntax is:
48///
49/// check = expr '=' expr
50///
51/// expr = binary_expr
52/// | sliceable_expr
53///
54/// sliceable_expr = '*{' number '}' load_addr_expr [slice]
55/// | '(' expr ')' [slice]
56/// | ident_expr [slice]
57/// | number [slice]
58///
59/// slice = '[' high-bit-index ':' low-bit-index ']'
60///
61/// load_addr_expr = symbol
62/// | '(' symbol '+' number ')'
63/// | '(' symbol '-' number ')'
64///
65/// ident_expr = 'decode_operand' '(' symbol ',' operand-index ')'
66/// | 'next_pc' '(' symbol ')'
67/// | 'stub_addr' '(' stub-container-name ',' symbol ')'
68/// | 'got_addr' '(' stub-container-name ',' symbol ')'
69/// | 'section_addr' '(' stub-container-name ',' symbol ')'
70/// | symbol
71///
72/// binary_expr = expr '+' expr
73/// | expr '-' expr
74/// | expr '&' expr
75/// | expr '|' expr
76/// | expr '<<' expr
77/// | expr '>>' expr
78///
80public:
82 public:
83 MemoryRegionInfo() = default;
84
85 /// Constructor for symbols/sections with content and TargetFlag.
87 TargetFlagsType TargetFlags)
88 : ContentPtr(Content.data()), Size(Content.size()),
89 TargetAddress(TargetAddress), TargetFlags(TargetFlags) {}
90
91 /// Constructor for zero-fill symbols/sections.
93 : Size(Size), TargetAddress(TargetAddress) {}
94
95 /// Returns true if this is a zero-fill symbol/section.
96 bool isZeroFill() const {
97 assert(Size && "setContent/setZeroFill must be called first");
98 return !ContentPtr;
99 }
100
101 /// Set the content for this memory region.
103 assert(!ContentPtr && !Size && "Content/zero-fill already set");
104 ContentPtr = Content.data();
105 Size = Content.size();
106 }
107
108 /// Set a zero-fill length for this memory region.
110 assert(!ContentPtr && !this->Size && "Content/zero-fill already set");
111 this->Size = Size;
112 }
113
114 /// Returns the content for this section if there is any.
116 assert(!isZeroFill() && "Can't get content for a zero-fill section");
117 return {ContentPtr, static_cast<size_t>(Size)};
118 }
119
120 /// Returns the zero-fill length for this section.
122 assert(isZeroFill() && "Can't get zero-fill length for content section");
123 return Size;
124 }
125
126 /// Set the target address for this region.
127 void setTargetAddress(JITTargetAddress TargetAddress) {
128 assert(!this->TargetAddress && "TargetAddress already set");
129 this->TargetAddress = TargetAddress;
130 }
131
132 /// Return the target address for this region.
133 JITTargetAddress getTargetAddress() const { return TargetAddress; }
134
135 /// Get the target flags for this Symbol.
136 TargetFlagsType getTargetFlags() const { return TargetFlags; }
137
138 /// Set the target flags for this Symbol.
140 assert(Flags <= 1 && "Add more bits to store more than one flag");
141 TargetFlags = Flags;
142 }
143
144 private:
145 const char *ContentPtr = nullptr;
146 uint64_t Size = 0;
147 JITTargetAddress TargetAddress = 0;
148 TargetFlagsType TargetFlags = 0;
149 };
150
151 using IsSymbolValidFunction = std::function<bool(StringRef Symbol)>;
153 std::function<Expected<MemoryRegionInfo>(StringRef SymbolName)>;
154 using GetSectionInfoFunction = std::function<Expected<MemoryRegionInfo>(
155 StringRef FileName, StringRef SectionName)>;
156 using GetStubInfoFunction = std::function<Expected<MemoryRegionInfo>(
157 StringRef StubContainer, StringRef TargetName, StringRef StubKindFilter)>;
158 using GetGOTInfoFunction = std::function<Expected<MemoryRegionInfo>(
159 StringRef GOTContainer, StringRef TargetName)>;
160
162 GetSymbolInfoFunction GetSymbolInfo,
163 GetSectionInfoFunction GetSectionInfo,
164 GetStubInfoFunction GetStubInfo,
165 GetGOTInfoFunction GetGOTInfo, llvm::endianness Endianness,
167 raw_ostream &ErrStream);
169
170 /// Check a single expression against the attached RuntimeDyld
171 /// instance.
172 bool check(StringRef CheckExpr) const;
173
174 /// Scan the given memory buffer for lines beginning with the string
175 /// in RulePrefix. The remainder of the line is passed to the check
176 /// method to be evaluated as an expression.
177 bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const;
178
179 /// Returns the address of the requested section (or an error message
180 /// in the second element of the pair if the address cannot be found).
181 ///
182 /// if 'LocalAddress' is true, this returns the address of the section
183 /// within the linker's memory. If 'LocalAddress' is false it returns the
184 /// address within the target process (i.e. the load address).
185 std::pair<uint64_t, std::string> getSectionAddr(StringRef FileName,
187 bool LocalAddress);
188
189 /// If there is a section at the given local address, return its load
190 /// address, otherwise return std::nullopt.
191 std::optional<uint64_t> getSectionLoadAddress(void *LocalAddress) const;
192
193private:
194 std::unique_ptr<RuntimeDyldCheckerImpl> Impl;
195};
196
197} // end namespace llvm
198
199#endif
T Content
#define check(cond)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:51
void setContent(ArrayRef< char > Content)
Set the content for this memory region.
void setZeroFill(uint64_t Size)
Set a zero-fill length for this memory region.
void setTargetFlags(TargetFlagsType Flags)
Set the target flags for this Symbol.
JITTargetAddress getTargetAddress() const
Return the target address for this region.
MemoryRegionInfo(ArrayRef< char > Content, JITTargetAddress TargetAddress, TargetFlagsType TargetFlags)
Constructor for symbols/sections with content and TargetFlag.
void setTargetAddress(JITTargetAddress TargetAddress)
Set the target address for this region.
ArrayRef< char > getContent() const
Returns the content for this section if there is any.
uint64_t getZeroFillLength() const
Returns the zero-fill length for this section.
MemoryRegionInfo(uint64_t Size, JITTargetAddress TargetAddress)
Constructor for zero-fill symbols/sections.
TargetFlagsType getTargetFlags() const
Get the target flags for this Symbol.
bool isZeroFill() const
Returns true if this is a zero-fill symbol/section.
RuntimeDyld invariant checker for verifying that RuntimeDyld has correctly applied relocations.
std::pair< uint64_t, std::string > getSectionAddr(StringRef FileName, StringRef SectionName, bool LocalAddress)
Returns the address of the requested section (or an error message in the second element of the pair i...
bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const
Scan the given memory buffer for lines beginning with the string in RulePrefix.
std::function< bool(StringRef Symbol)> IsSymbolValidFunction
std::optional< uint64_t > getSectionLoadAddress(void *LocalAddress) const
If there is a section at the given local address, return its load address, otherwise return std::null...
std::function< Expected< MemoryRegionInfo >(StringRef StubContainer, StringRef TargetName, StringRef StubKindFilter)> GetStubInfoFunction
std::function< Expected< MemoryRegionInfo >(StringRef FileName, StringRef SectionName)> GetSectionInfoFunction
std::function< Expected< MemoryRegionInfo >(StringRef GOTContainer, StringRef TargetName)> GetGOTInfoFunction
std::function< Expected< MemoryRegionInfo >(StringRef SymbolName)> GetSymbolInfoFunction
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Manages the enabling and disabling of subtarget specific features.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1689
uint8_t TargetFlagsType
Holds target-specific properties for a symbol.
endianness
Definition: bit.h:70