Skip to content

zoc: Stepwise compilation and output #483

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
JoelleJS wants to merge 4 commits into
base: master
Choose a base branch
from
Open

zoc: Stepwise compilation and output #483

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
02de35e
comgr: refactor
JoelleJS Aug 14, 2025
2cd7f3e
comgr: Prepare for splitting source-to-executable in substeps
JoelleJS Aug 27, 2025
96f66d3
comgr: Stepwise compilation for zoc
JoelleJS Aug 27, 2025
ee008ec
comgr: Unnecessary (and incorrect) lines removed
JoelleJS Aug 27, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
134 changes: 97 additions & 37 deletions comgr/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -138,11 +138,24 @@ impl<'a> DataSet<'a> {
Ok(())
}

pub fn from_data(comgr: &'a Comgr, data: impl Iterator<Item = Data>) -> Result<Self, Error> {
let dataset = Self::new(comgr)?;
for data in data {
dataset.add(&data)?;
}
Ok(dataset)
}

fn get_data(&self, kind: DataKind, index: usize) -> Result<Data, Error> {
let mut handle = 0u64;
call_dispatch!(self.comgr => amd_comgr_action_data_get_data(self, kind, { index }, { std::ptr::from_mut(&mut handle).cast() }));
Ok(Data(handle))
}

fn get_content(&self, comgr: &Comgr, kind: DataKind, index: usize) -> Result<Vec<u8>, Error> {
self.get_data(kind, index)
.map(|data| data.copy_content(comgr))?
}
}

struct Data(u64);
Expand Down Expand Up @@ -196,28 +209,25 @@ pub fn compile_bitcode(
attributes_buffer: &[u8],
compiler_hook: Option<&dyn Fn(&Vec<u8>, String)>,
) -> Result<Vec<u8>, Error> {
let bitcode_data_set = DataSet::new(comgr)?;
let main_bitcode_data = Data::new(comgr, DataKind::Bc, c"zluda.bc", main_buffer)?;
bitcode_data_set.add(&main_bitcode_data)?;
let stdlib_bitcode_data = Data::new(comgr, DataKind::Bc, c"ptx_impl.bc", ptx_impl)?;
bitcode_data_set.add(&stdlib_bitcode_data)?;
let attributes_bitcode_data =
Data::new(comgr, DataKind::Bc, c"attributes.bc", attributes_buffer)?;
bitcode_data_set.add(&attributes_bitcode_data)?;
let bitcode_data_set = DataSet::from_data(
comgr,
[
Data::new(comgr, DataKind::Bc, c"zluda.bc", main_buffer)?,
Data::new(comgr, DataKind::Bc, c"ptx_impl.bc", ptx_impl)?,
Data::new(comgr, DataKind::Bc, c"attributes.bc", attributes_buffer)?,
]
.into_iter(),
)?;
let linking_info = ActionInfo::new(comgr)?;
let linked_data_set =
comgr.do_action(ActionKind::LinkBcToBc, &linking_info, &bitcode_data_set)?;
if let Some(hook) = compiler_hook {
// Run compiler hook on human-readable LLVM IR
let data = linked_data_set.get_data(DataKind::Bc, 0)?;
let data = data.copy_content(comgr)?;
let data = linked_data_set.get_content(comgr, DataKind::Bc, 0)?;
let data = ptx::bitcode_to_ir(data);
hook(&data, String::from("linked.ll"));
}

let compile_to_exec = ActionInfo::new(comgr)?;
compile_to_exec.set_isa_name(gcn_arch)?;
compile_to_exec.set_language(Language::LlvmIr)?;
let common_options = [
// This makes no sense, but it makes ockl linking work
c"-Xclang",
Expand Down Expand Up @@ -249,32 +259,78 @@ pub fn compile_bitcode(
c"-inlinehint-threshold=3250",
]
};
compile_to_exec.set_options(common_options.chain(opt_options))?;
let exec_data_set = comgr.do_action(
ActionKind::CompileSourceToExecutable,
&compile_to_exec,
&linked_data_set,
)?;
let executable = exec_data_set.get_data(DataKind::Executable, 0)?;
let executable = executable.copy_content(comgr);
let options = common_options.chain(opt_options);
let executable: Result<Vec<u8>, Error>;
if let Some(hook) = compiler_hook {
// Run compiler hook for executable
// CompileSourceWithDeviceLibsToBc
let action_info = ActionInfo::new(comgr)?;
action_info.set_isa_name(gcn_arch)?;
action_info.set_language(Language::LlvmIr)?;
action_info.set_options(options.clone())?;
let dataset = comgr.do_action(
ActionKind::CompileSourceWithDeviceLibsToBc,
&action_info,
&linked_data_set,
)?;
let data = dataset.get_content(comgr, DataKind::Bc, 0)?;
let data = ptx::bitcode_to_ir(data);

@vosen vosen Aug 27, 2025

Copy link
Copy Markdown
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This fails with Invalid attribute group entry (Producer: 'LLVM19.0.0git' Reader: 'LLVM 17.0.6'), which makes sense. LLVM that ZLUDA links to is (deliberately) 17.0.6, while comgr is whatever ships with HIP (18 or 19). Older LLVM can't read newer bitcode.
Not sure if there is a good solution to this. This should be handled by comgr itself and it does not look like comgr exposes this capability? There's a promising AMD_COMGR_ACTION_DISASSEMBLE_BYTES_TO_SOURCE, but it seems to be used only for input filtering, disassembly seems to be an equivalent of objdump, so ELF/COFF only.

Not sure if there's a good solution is here. On linux one could try to to sniff path to llvm-dis? Start with the comgr path via dlinfo and try to call llvm-dis relative to it (on my machine comgr is in /opt/rocm/lib and llvm-dis is in /opt/rocm/llvm/bin/

If there is no good solution feel free to just comment it out with appropriate note

hook(&data, String::from("with-device-libs.ll"));

// CodegenBcToRelocatable
let action_info = ActionInfo::new(comgr)?;
action_info.set_isa_name(gcn_arch)?;
action_info.set_options(options.clone())?;
let dataset =
comgr.do_action(ActionKind::CodegenBcToRelocatable, &action_info, &dataset)?;
let data = dataset.get_content(comgr, DataKind::Relocatable, 0)?;
hook(&data, String::from("relocatable.elf"));

// Disassemble relocatable
let action_info = ActionInfo::new(comgr)?;
action_info.set_isa_name(gcn_arch)?;
let disassembled_dataset = comgr.do_action(
ActionKind::DisassembleRelocatableToSource,
&action_info,
&dataset,
)?;
let disassembly = disassembled_dataset.get_content(comgr, DataKind::Source, 0)?;
hook(&disassembly, String::from("relocatable.asm"));

// LinkRelocatableToExecutable
let action_info = ActionInfo::new(comgr)?;
action_info.set_isa_name(gcn_arch)?;
let dataset = comgr.do_action(
ActionKind::LinkRelocatableToExecutable,
&action_info,
&dataset,
)?;
executable = dataset.get_content(comgr, DataKind::Executable, 0);
hook(
executable.as_ref().unwrap_or(&Vec::new()),
String::from("elf"),
);

// Disassemble executable and run compiler hook
// Disassemble executable
let action_info = ActionInfo::new(comgr)?;
action_info.set_isa_name(gcn_arch)?;
let disassembly = comgr.do_action(
let disassembled_dataset = comgr.do_action(
ActionKind::DisassembleExecutableToSource,
&action_info,
&exec_data_set,
&dataset,
)?;
let disassembly = disassembled_dataset.get_content(comgr, DataKind::Source, 0)?;
hook(&disassembly, String::from("asm"));
} else {
let compile_to_exec = ActionInfo::new(comgr)?;
compile_to_exec.set_isa_name(gcn_arch)?;
compile_to_exec.set_language(Language::LlvmIr)?;
compile_to_exec.set_options(options.clone())?;
let exec_data_set = comgr.do_action(
ActionKind::CompileSourceToExecutable,
&compile_to_exec,
&linked_data_set,
)?;
let disassembly = disassembly.get_data(DataKind::Source, 0)?;
let disassembly = disassembly.copy_content(comgr);
hook(&disassembly.unwrap_or(Vec::new()), String::from("asm"))
executable = exec_data_set.get_content(comgr, DataKind::Executable, 0);
}
executable
}
Expand All @@ -296,14 +352,15 @@ pub fn get_symbols(comgr: &Comgr, elf: &[u8]) -> Result<Vec<(u32, String)>, Erro
}

pub fn get_clang_version(comgr: &Comgr) -> Result<String, Error> {
let version_string_set = DataSet::new(comgr)?;
let version_string = Data::new(
let version_string_set = DataSet::from_data(
comgr,
DataKind::Source,
c"version.cpp",
b"__clang_version__",
iter::once(Data::new(
comgr,
DataKind::Source,
c"version.cpp",
b"__clang_version__",
)?),
)?;
version_string_set.add(&version_string)?;
let preprocessor_info = ActionInfo::new(comgr)?;
preprocessor_info.set_language(Language::Hip)?;
preprocessor_info.set_options(iter::once(c"-P"))?;
Expand All @@ -312,9 +369,8 @@ pub fn get_clang_version(comgr: &Comgr) -> Result<String, Error> {
&preprocessor_info,
&version_string_set,
)?;
let data = preprocessed.get_data(DataKind::Source, 0)?;
String::from_utf8(trim_whitespace_and_quotes(data.copy_content(comgr)?)?)
.map_err(|_| Error::UNKNOWN)
let data = preprocessed.get_content(comgr, DataKind::Source, 0)?;
String::from_utf8(trim_whitespace_and_quotes(data)?).map_err(|_| Error::UNKNOWN)
}

// When running the preprocessor to expand the macro the output is surrounded by
Expand Down Expand Up @@ -540,6 +596,10 @@ impl_into!(
[
LinkBcToBc => AMD_COMGR_ACTION_LINK_BC_TO_BC,
CompileSourceToExecutable => AMD_COMGR_ACTION_COMPILE_SOURCE_TO_EXECUTABLE,
CompileSourceWithDeviceLibsToBc => AMD_COMGR_ACTION_COMPILE_SOURCE_WITH_DEVICE_LIBS_TO_BC,
CodegenBcToRelocatable => AMD_COMGR_ACTION_CODEGEN_BC_TO_RELOCATABLE,
DisassembleRelocatableToSource => AMD_COMGR_ACTION_DISASSEMBLE_RELOCATABLE_TO_SOURCE,
LinkRelocatableToExecutable => AMD_COMGR_ACTION_LINK_RELOCATABLE_TO_EXECUTABLE,
DisassembleExecutableToSource => AMD_COMGR_ACTION_DISASSEMBLE_EXECUTABLE_TO_SOURCE,
SourceToPreprocessor => AMD_COMGR_ACTION_SOURCE_TO_PREPROCESSOR
]
Expand Down
Loading