Alex Voicu
134 строки
3.8 KiB
C++
134 строки
3.8 KiB
C++
#pragma once
|
|
|
|
#include <hsa/hsa.h>
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <istream>
|
|
#include <iterator>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace hip_impl
|
|
{
|
|
hsa_isa_t triple_to_hsa_isa(const std::string& triple);
|
|
|
|
struct Bundled_code {
|
|
union {
|
|
struct {
|
|
std::uint64_t offset;
|
|
std::uint64_t bundle_sz;
|
|
std::uint64_t triple_sz;
|
|
};
|
|
std::uint8_t cbuf[
|
|
sizeof(offset) + sizeof(bundle_sz) + sizeof(triple_sz)];
|
|
};
|
|
std::string triple;
|
|
std::vector<std::uint8_t> blob;
|
|
};
|
|
|
|
class Bundled_code_header {
|
|
// DATA - STATICS
|
|
static constexpr const char magic_string_[] =
|
|
"__CLANG_OFFLOAD_BUNDLE__";
|
|
static constexpr auto magic_string_sz_ = sizeof(magic_string_) - 1;
|
|
|
|
// DATA
|
|
union {
|
|
struct {
|
|
std::uint8_t bundler_magic_string_[magic_string_sz_];
|
|
std::uint64_t bundle_cnt_;
|
|
};
|
|
std::uint8_t cbuf_[
|
|
sizeof(bundler_magic_string_) + sizeof(bundle_cnt_)];
|
|
};
|
|
std::vector<Bundled_code> bundles_;
|
|
|
|
// FRIENDS - MANIPULATORS
|
|
template<typename RandomAccessIterator>
|
|
friend
|
|
inline
|
|
bool read(
|
|
RandomAccessIterator f,
|
|
RandomAccessIterator l,
|
|
Bundled_code_header& x)
|
|
{
|
|
std::copy_n(f, sizeof(x.cbuf_), x.cbuf_);
|
|
|
|
if (valid(x)) {
|
|
x.bundles_.resize(x.bundle_cnt_);
|
|
|
|
auto it = f + sizeof(x.cbuf_);
|
|
for (auto&& y : x.bundles_) {
|
|
std::copy_n(it, sizeof(y.cbuf), y.cbuf);
|
|
it += sizeof(y.cbuf);
|
|
|
|
y.triple.insert(y.triple.cend(), it, it + y.triple_sz);
|
|
|
|
std::copy_n(
|
|
f + y.offset, y.bundle_sz, std::back_inserter(y.blob));
|
|
|
|
it += y.triple_sz;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
friend
|
|
inline
|
|
bool read(const std::vector<std::uint8_t>& blob, Bundled_code_header& x)
|
|
{
|
|
return read(blob.cbegin(), blob.cend(), x);
|
|
}
|
|
friend
|
|
inline
|
|
bool read(std::istream& is, Bundled_code_header& x)
|
|
{
|
|
return read(std::vector<std::uint8_t>{
|
|
std::istreambuf_iterator<char>{is},
|
|
std::istreambuf_iterator<char>{}},
|
|
x);
|
|
}
|
|
|
|
// FRIENDS - ACCESSORS
|
|
friend
|
|
inline
|
|
bool valid(const Bundled_code_header& x)
|
|
{
|
|
return std::equal(
|
|
x.bundler_magic_string_,
|
|
x.bundler_magic_string_ + magic_string_sz_,
|
|
x.magic_string_);
|
|
}
|
|
friend
|
|
inline
|
|
const std::vector<Bundled_code>& bundles(const Bundled_code_header& x)
|
|
{
|
|
return x.bundles_;
|
|
}
|
|
public:
|
|
// CREATORS
|
|
Bundled_code_header() = default;
|
|
template<typename RandomAccessIterator>
|
|
Bundled_code_header(RandomAccessIterator f, RandomAccessIterator l);
|
|
explicit
|
|
Bundled_code_header(const std::vector<std::uint8_t>& blob);
|
|
Bundled_code_header(const Bundled_code_header&) = default;
|
|
Bundled_code_header(Bundled_code_header&&) = default;
|
|
~Bundled_code_header() = default;
|
|
|
|
// MANIPULATORS
|
|
Bundled_code_header& operator=(const Bundled_code_header&) = default;
|
|
Bundled_code_header& operator=(Bundled_code_header&&) = default;
|
|
};
|
|
|
|
// CREATORS
|
|
template<typename I>
|
|
Bundled_code_header::Bundled_code_header(I f, I l) : Bundled_code_header{}
|
|
{
|
|
read(f, l, *this);
|
|
}
|
|
} // Namespace hip_impl.
|