mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-26 04:32:44 +01:00
6f39af85a4
Currently there is no way to describe the data that is not a part of an output section.
It can be a data used to align sections or to fill the gaps with something,
or another kind of custom data. In this patch I suggest a way to describe it. It looks like that:
```
Sections:
- Type: CustomFiller
Pattern: "CCDD"
Size: 4
- Name: .bar
Type: SHT_PROGBITS
Content: "FF"
```
I.e. I've added a kind of synthetic section with a synthetic type "CustomFiller".
In the code it is called a "SyntheticFiller", which is "a synthetic section which
might be used to write the custom data around regular output sections. It does
not present in the sections header table, but it might affect the output file size and
program headers produced. Think about it as about piece of data."
`SyntheticFiller` currently has a `Pattern` field and a `Size` field + an optional `Name`.
When written, `Size` of bytes in the output will be filled with a `Pattern`.
It is possible to reference a named filler it by name from the program headers description,
just like any other normal section.
Differential revision: https://reviews.llvm.org/D69709
117 lines
3.7 KiB
C++
117 lines
3.7 KiB
C++
//===- YAML.h ---------------------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_OBJECTYAML_YAML_H
|
|
#define LLVM_OBJECTYAML_YAML_H
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
#include <cstdint>
|
|
|
|
namespace llvm {
|
|
|
|
class raw_ostream;
|
|
|
|
namespace yaml {
|
|
|
|
/// Specialized YAMLIO scalar type for representing a binary blob.
|
|
///
|
|
/// A typical use case would be to represent the content of a section in a
|
|
/// binary file.
|
|
/// This class has custom YAMLIO traits for convenient reading and writing.
|
|
/// It renders as a string of hex digits in a YAML file.
|
|
/// For example, it might render as `DEADBEEFCAFEBABE` (YAML does not
|
|
/// require the quotation marks, so for simplicity when outputting they are
|
|
/// omitted).
|
|
/// When reading, any string whose content is an even number of hex digits
|
|
/// will be accepted.
|
|
/// For example, all of the following are acceptable:
|
|
/// `DEADBEEF`, `"DeADbEeF"`, `"\x44EADBEEF"` (Note: '\x44' == 'D')
|
|
///
|
|
/// A significant advantage of using this class is that it never allocates
|
|
/// temporary strings or buffers for any of its functionality.
|
|
///
|
|
/// Example:
|
|
///
|
|
/// The YAML mapping:
|
|
/// \code
|
|
/// Foo: DEADBEEFCAFEBABE
|
|
/// \endcode
|
|
///
|
|
/// Could be modeled in YAMLIO by the struct:
|
|
/// \code
|
|
/// struct FooHolder {
|
|
/// BinaryRef Foo;
|
|
/// };
|
|
/// namespace llvm {
|
|
/// namespace yaml {
|
|
/// template <>
|
|
/// struct MappingTraits<FooHolder> {
|
|
/// static void mapping(IO &IO, FooHolder &FH) {
|
|
/// IO.mapRequired("Foo", FH.Foo);
|
|
/// }
|
|
/// };
|
|
/// } // end namespace yaml
|
|
/// } // end namespace llvm
|
|
/// \endcode
|
|
class BinaryRef {
|
|
friend bool operator==(const BinaryRef &LHS, const BinaryRef &RHS);
|
|
|
|
/// Either raw binary data, or a string of hex bytes (must always
|
|
/// be an even number of characters).
|
|
ArrayRef<uint8_t> Data;
|
|
|
|
/// Discriminator between the two states of the `Data` member.
|
|
bool DataIsHexString = true;
|
|
|
|
public:
|
|
BinaryRef() = default;
|
|
BinaryRef(ArrayRef<uint8_t> Data) : Data(Data), DataIsHexString(false) {}
|
|
BinaryRef(StringRef Data) : Data(arrayRefFromStringRef(Data)) {}
|
|
|
|
/// The number of bytes that are represented by this BinaryRef.
|
|
/// This is the number of bytes that writeAsBinary() will write.
|
|
ArrayRef<uint8_t>::size_type binary_size() const {
|
|
if (DataIsHexString)
|
|
return Data.size() / 2;
|
|
return Data.size();
|
|
}
|
|
|
|
/// Write the contents (regardless of whether it is binary or a
|
|
/// hex string) as binary to the given raw_ostream.
|
|
/// N can be used to specify the maximum number of bytes.
|
|
void writeAsBinary(raw_ostream &OS, uint64_t N = UINT64_MAX) const;
|
|
|
|
/// Write the contents (regardless of whether it is binary or a
|
|
/// hex string) as hex to the given raw_ostream.
|
|
///
|
|
/// For example, a possible output could be `DEADBEEFCAFEBABE`.
|
|
void writeAsHex(raw_ostream &OS) const;
|
|
};
|
|
|
|
inline bool operator==(const BinaryRef &LHS, const BinaryRef &RHS) {
|
|
// Special case for default constructed BinaryRef.
|
|
if (LHS.Data.empty() && RHS.Data.empty())
|
|
return true;
|
|
|
|
return LHS.DataIsHexString == RHS.DataIsHexString && LHS.Data == RHS.Data;
|
|
}
|
|
|
|
template <> struct ScalarTraits<BinaryRef> {
|
|
static void output(const BinaryRef &, void *, raw_ostream &);
|
|
static StringRef input(StringRef, void *, BinaryRef &);
|
|
static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
|
|
};
|
|
|
|
} // end namespace yaml
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif // LLVM_OBJECTYAML_YAML_H
|