Fix and test, improve compilation slightly

comgr/src/lib.rs

@@ -1,5 +1,5 @@
 use amd_comgr_sys::*;
-use std::{ffi::CStr, mem, ptr};
+use std::{ffi::CStr, iter, mem, ptr};
 
 struct Data(amd_comgr_data_t);
 
@@ -83,6 +83,20 @@ impl ActionInfo {
         unsafe { amd_comgr_action_info_set_language(self.get(), language) }
     }
 
+    fn set_options<'a>(
+        &self,
+        options: impl Iterator<Item = &'a CStr>,
+    ) -> Result<(), amd_comgr_status_s> {
+        let options = options.map(|x| x.as_ptr()).collect::<Vec<_>>();
+        unsafe {
+            amd_comgr_action_info_set_option_list(
+                self.get(),
+                options.as_ptr().cast_mut(),
+                options.len(),
+            )
+        }
+    }
+
     fn get(&self) -> amd_comgr_action_info_t {
         self.0
     }
@@ -116,21 +130,27 @@ pub fn compile_bitcode(
     let lang_action_info = ActionInfo::new()?;
     lang_action_info.set_isa_name(gcn_arch)?;
     lang_action_info.set_language(amd_comgr_language_t::AMD_COMGR_LANGUAGE_LLVM_IR)?;
-    let linked_data_set = do_action(
+    let with_device_libs = do_action(
         &bitcode_data_set,
         &lang_action_info,
         amd_comgr_action_kind_t::AMD_COMGR_ACTION_COMPILE_SOURCE_WITH_DEVICE_LIBS_TO_BC,
     )?;
-    let action_info = ActionInfo::new()?;
-    action_info.set_isa_name(gcn_arch)?;
+    let linked_data_set = do_action(
+        &with_device_libs,
+        &lang_action_info,
+        amd_comgr_action_kind_t::AMD_COMGR_ACTION_LINK_BC_TO_BC,
+    )?;
+    let compile_action_info = ActionInfo::new()?;
+    compile_action_info.set_isa_name(gcn_arch)?;
+    compile_action_info.set_options(iter::once(c"-O3"))?;
     let reloc_data_set = do_action(
         &linked_data_set,
-        &action_info,
+        &compile_action_info,
         amd_comgr_action_kind_t::AMD_COMGR_ACTION_CODEGEN_BC_TO_RELOCATABLE,
     )?;
     let exec_data_set = do_action(
         &reloc_data_set,
-        &action_info,
+        &compile_action_info,
         amd_comgr_action_kind_t::AMD_COMGR_ACTION_LINK_RELOCATABLE_TO_EXECUTABLE,
     )?;
     let executable =

ptx/src/pass/emit_llvm.rs

@@ -338,7 +338,7 @@ impl<'a, 'input> MethodEmitContext<'a, 'input> {
             Statement::Conversion(conversion) => self.emit_conversion(conversion)?,
             Statement::Constant(constant) => self.emit_constant(constant)?,
             Statement::RetValue(_, _) => todo!(),
-            Statement::PtrAccess(_) => todo!(),
+            Statement::PtrAccess(ptr_access) => self.emit_ptr_access(ptr_access)?,
             Statement::RepackVector(_) => todo!(),
             Statement::FunctionPointer(_) => todo!(),
             Statement::VectorAccess(_) => todo!(),
@@ -400,7 +400,7 @@ impl<'a, 'input> MethodEmitContext<'a, 'input> {
             ast::Instruction::SetpBool { data, arguments } => todo!(),
             ast::Instruction::Not { data, arguments } => todo!(),
             ast::Instruction::Or { data, arguments } => todo!(),
-            ast::Instruction::And { data, arguments } => todo!(),
+            ast::Instruction::And { data, arguments } => self.emit_and(arguments),
             ast::Instruction::Bra { arguments } => todo!(),
             ast::Instruction::Call { data, arguments } => self.emit_call(data, arguments),
             ast::Instruction::Cvt { data, arguments } => todo!(),
@@ -448,9 +448,6 @@ impl<'a, 'input> MethodEmitContext<'a, 'input> {
         data: ast::LdDetails,
         arguments: ast::LdArgs<SpirvWord>,
     ) -> Result<(), TranslateError> {
-        if data.non_coherent {
-            todo!()
-        }
         if data.qualifier != ast::LdStQualifier::Weak {
             todo!()
         }
@@ -492,7 +489,7 @@ impl<'a, 'input> MethodEmitContext<'a, 'input> {
                 } else {
                     todo!()
                 }
-            },
+            }
             ConversionKind::SignExtend => todo!(),
             ConversionKind::BitToPtr => {
                 let src = self.resolver.value(conversion.src)?;
@@ -618,6 +615,26 @@ impl<'a, 'input> MethodEmitContext<'a, 'input> {
             .register(arguments.dst, self.resolver.value(arguments.src)?);
         Ok(())
     }
+
+    fn emit_ptr_access(&mut self, ptr_access: PtrAccess<SpirvWord>) -> Result<(), TranslateError> {
+        let ptr_src = self.resolver.value(ptr_access.ptr_src)?;
+        let mut offset_src = self.resolver.value(ptr_access.offset_src)?;
+        let pointee_type = get_scalar_type(self.context, ast::ScalarType::B8);
+        self.resolver.with_result(ptr_access.dst, |dst| unsafe {
+            LLVMBuildInBoundsGEP2(self.builder, pointee_type, ptr_src, &mut offset_src, 1, dst)
+        });
+        Ok(())
+    }
+
+    fn emit_and(&mut self, arguments: ast::AndArgs<SpirvWord>) -> Result<(), TranslateError> {
+        let builder = self.builder;
+        let src1 = self.resolver.value(arguments.src1)?;
+        let src2 = self.resolver.value(arguments.src2)?;
+        self.resolver.with_result(arguments.dst, |dst| unsafe {
+            LLVMBuildAnd(builder, src1, src2, dst)
+        });
+        Ok(())
+    }
 }
 
 fn get_pointer_type<'ctx>(