Rely on code object metadat for kernarg arguments alignof and sizeof.

hipamd/src/program_state.cpp

@@ -306,8 +306,8 @@ const unordered_map<string, vector<hsa_executable_symbol_t>>& kernels(bool rebui
 
 void load_code_object_and_freeze_executable(
     const string& file, hsa_agent_t agent,
-    hsa_executable_t
-        executable) {  // TODO: the following sequence is inefficient, should be refactored
+    hsa_executable_t executable) {
+    // TODO: the following sequence is inefficient, should be refactored
     //       into a single load of the file and subsequent ELFIO
     //       processing.
     static const auto cor_deleter = [](hsa_code_object_reader_t* p) {
@@ -334,6 +334,85 @@ void load_code_object_and_freeze_executable(
         code_readers.push_back(move(tmp));
     }
 }
+
+size_t parse_args(
+    const string& metadata,
+    size_t f,
+    size_t l,
+    vector<pair<size_t, size_t>>& size_align) {
+    if (f == l) return f;
+
+    do {
+        static constexpr size_t size_sz{5};
+        f = metadata.find("Size:", f) + size_sz;
+
+        if (l <= f) return f;
+
+        auto size = strtoul(&metadata[f], nullptr, 10);
+
+        static constexpr size_t align_sz{6};
+        f = metadata.find("Align:", f) + align_sz;
+
+        char* l{};
+        auto align = strtoul(&metadata[f], &l, 10);
+
+        f += (l - &metadata[f]) + 1;
+
+        size_align.emplace_back(size, align);
+    } while (true);
+}
+
+void read_kernarg_metadata(
+    elfio& reader,
+    unordered_map<string, vector<pair<size_t, size_t>>>& kernargs)
+{   // TODO: this is inefficient.
+    auto it = find_section_if(
+        reader, [](const section* x) { return x->get_type() == SHT_NOTE; });
+
+    if (!it) return;
+
+    const note_section_accessor acc{reader, it};
+    for (decltype(acc.get_notes_num()) i = 0; i != acc.get_notes_num(); ++i) {
+        ELFIO::Elf_Word type{};
+        string name{};
+        void* desc{};
+        Elf_Word desc_size{};
+
+        acc.get_note(i, type, name, desc, desc_size);
+
+        if (name != "AMD") continue; // TODO: switch to using NT_AMD_AMDGPU_HSA_METADATA.
+
+        string tmp{
+            static_cast<char*>(desc), static_cast<char*>(desc) + desc_size};
+
+        auto dx = tmp.find("Kernels:");
+
+        if (dx == string::npos) continue;
+
+        static constexpr decltype(tmp.size()) kernels_sz{8};
+        dx += kernels_sz;
+
+        do {
+            dx = tmp.find("Name:", dx);
+
+            if (dx == string::npos) break;
+
+            static constexpr decltype(tmp.size()) name_sz{5};
+            dx = tmp.find_first_not_of(' ', dx + name_sz);
+
+            auto fn = tmp.substr(dx, tmp.find('\n', dx) - dx);
+            dx += fn.size();
+
+            dx = tmp.find("Args:", dx);
+
+            if (dx == string::npos) break;
+
+            static constexpr decltype(tmp.size()) args_sz{5};
+            dx = parse_args(
+                tmp, dx + args_sz, tmp.find("CodeProps", dx), kernargs[fn]);
+        } while (true);
+    }
+}
 }  // namespace
 
 namespace hip_impl {
@@ -495,6 +574,25 @@ unordered_map<string, void*>& globals(bool rebuild) {
     return r;
 }
 
+unordered_map<string, vector<pair<size_t, size_t>>>& kernargs() {
+    static unordered_map<string, vector<pair<size_t, size_t>>> r;
+    static once_flag f;
+
+    call_once(f, []() {
+        for (auto&& blob : code_object_blobs()) {
+            stringstream tmp{std::string{
+                blob.second.front().cbegin(), blob.second.front().cend()}};
+
+            elfio reader;
+            if (!reader.load(tmp)) continue;
+
+            read_kernarg_metadata(reader, r);
+        }
+    });
+
+    return r;
+}
+
 hsa_executable_t load_executable(const string& file, hsa_executable_t executable,
                                  hsa_agent_t agent) {
     elfio reader;