Change LLVM restraints, fix some errors that shouldn't exist

Author: matt-cornell

cobalt-ast/Cargo.toml

@@ -24,3 +24,4 @@ inventory = "0.3.12"
 once_cell = "1.18.0"
 hashbrown = "0.14.2"
 flurry = "0.4.0"
+thiserror = "1.0.51"

cobalt-ast/src/context.rs

@@ -9,6 +9,22 @@ use std::cell::{Cell, RefCell};
 use std::io::{self, BufRead, Read, Write};
 use std::mem::MaybeUninit;
 use std::pin::Pin;
+use thiserror::Error;
+
+type HeaderVersionType = u16;
+/// Simple number to check if a header is compatible for loading
+/// Bump this whenever a breaking change is made to the format
+const HEADER_FMT_VERSION: HeaderVersionType = 0;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
+#[error("expected header version {HEADER_FMT_VERSION}, found version {0}")]
+pub struct HeaderVersionError(pub HeaderVersionType);
+impl From<HeaderVersionError> for io::Error {
+    fn from(value: HeaderVersionError) -> Self {
+        io::Error::new(io::ErrorKind::Other, value)
+    }
+}
+
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Flags {
     pub word_size: u16,
@@ -17,6 +33,7 @@ pub struct Flags {
     pub dbg_mangle: bool,
     pub all_move_metadata: bool,
     pub private_syms: bool,
+    pub skip_header_version_check: bool,
 }
 impl Default for Flags {
     fn default() -> Self {
@@ -27,9 +44,11 @@ impl Default for Flags {
             dbg_mangle: false,
             all_move_metadata: false,
             private_syms: true,
+            skip_header_version_check: false,
         }
     }
 }
+
 pub struct CompCtx<'src, 'ctx> {
     pub flags: Flags,
     pub context: &'ctx Context,
@@ -277,6 +296,7 @@ impl<'src, 'ctx> CompCtx<'src, 'ctx> {
         Some(v)
     }
     pub fn save<W: Write>(&self, out: &mut W) -> io::Result<()> {
+        out.write_all(&HEADER_FMT_VERSION.to_be_bytes())?;
         for info in inventory::iter::<types::TypeLoader> {
             out.write_all(&info.kind.get().to_be_bytes())?;
             (info.save_header)(out)?;
@@ -285,6 +305,14 @@ impl<'src, 'ctx> CompCtx<'src, 'ctx> {
         self.with_vars(|v| v.save(out))
     }
     pub fn load<R: Read + BufRead>(&self, buf: &mut R) -> io::Result<Vec<Cow<'src, str>>> {
+        {
+            let mut arr = [0; std::mem::size_of::<HeaderVersionType>()];
+            buf.read_exact(&mut arr)?;
+            let version = HeaderVersionType::from_be_bytes(arr);
+            if !(self.flags.skip_header_version_check || version == HEADER_FMT_VERSION) {
+                Err(HeaderVersionError(version))?;
+            }
+        }
         let mut out = vec![];
         while !buf.fill_buf()?.is_empty() {
             let mut bytes = [0u8; 8];

cobalt-build/Cargo.toml

@@ -31,7 +31,6 @@ object = { version = "0.32.1", features = ["write"] }
 anyhow = "1.0.75"
 anyhow-std = "0.1.4"
 thiserror = "1.0.50"
-llvm-sys = "160"
 lasso = { version = "0.7.2", features = ["multi-threaded"] }
 indexmap = "2.0.2"
 os_str_bytes = { version = "6.6.1", features = ["conversions"] }
@@ -51,4 +50,4 @@ config-json = ["serde_json"]
 config-all = ["config-toml", "config-json"]
 cc-build = ["cc"]
 build-default = ["cc-build", "config-all"]
-default = ["build-default"]
+default = ["build-default"]

cobalt-cli/src/lib.rs

@@ -1744,8 +1744,12 @@ pub fn driver(cli: Cli) -> anyhow::Result<()> {
                         reporter.insts_after += insts(&ctx.module);
                         let input = PathBuf::from(file.name());
                         let mut out = match &output {
-                            None => input,
-                            Some(p) => p.join(input),
+                            None => ClioPath::new(input)?,
+                            Some(p) => {
+                                let mut p = p.clone();
+                                p.push(input);
+                                p
+                            }
                         };
                         if !matches!(
                             emit,
@@ -1763,7 +1767,7 @@ pub fn driver(cli: Cli) -> anyhow::Result<()> {
                                 let mut buf = vec![];
                                 *reporter.cg_time.get_or_insert(Duration::ZERO) +=
                                     try_timeit(|| ctx.save(&mut buf))?.1;
-                                Path::new(&out).write_anyhow(buf)?;
+                                out.create_with_len(buf.len() as _)?.write_all(&buf)?;
                                 Zero
                             }
                             OutputType::HeaderObj => {
@@ -1774,21 +1778,21 @@ pub fn driver(cli: Cli) -> anyhow::Result<()> {
                                     obj.write()
                                 })?;
                                 *reporter.cg_time.get_or_insert(Duration::ZERO) += cg_time;
-                                Path::new(&out).write_anyhow(vec)?;
+                                out.create_with_len(vec.len() as _)?.write_all(&vec)?;
                                 Zero
                             }
                             OutputType::Llvm => {
                                 out.set_extension("ll");
                                 let (m, cg_time) = timeit(|| ctx.module.to_string());
                                 *reporter.cg_time.get_or_insert(Duration::ZERO) += cg_time;
-                                Path::new(&out).write_anyhow(m)?;
+                                out.create_with_len(m.len() as _)?.write_all(m.as_bytes())?;
                                 Zero
                             }
                             OutputType::Bitcode => {
                                 out.set_extension("bc");
                                 let (m, cg_time) = timeit(|| ctx.module.write_bitcode_to_memory());
                                 *reporter.cg_time.get_or_insert(Duration::ZERO) += cg_time;
-                                Path::new(&out).write_anyhow(m.as_slice())?;
+                                out.create_with_len(m.get_size() as _)?.write_all(m.as_slice())?;
                                 Zero
                             }
                             OutputType::Assembly => {
@@ -1802,7 +1806,7 @@ pub fn driver(cli: Cli) -> anyhow::Result<()> {
                                         .unwrap()
                                 });
                                 *reporter.cg_time.get_or_insert(Duration::ZERO) += cg_time;
-                                Path::new(&out).write_anyhow(m.as_slice())?;
+                                out.create_with_len(m.get_size() as _)?.write_all(m.as_slice())?;
                                 Zero
                             }
                             _ => {
@@ -1838,16 +1842,16 @@ pub fn driver(cli: Cli) -> anyhow::Result<()> {
                                         out.set_extension("o");
                                         archive.as_mut().unwrap().append(
                                             &ar::Header::new(
-                                                out.into_raw_vec(),
-                                                mb.as_slice().len() as _,
+                                                out.to_os_string().into_raw_vec(),
+                                                mb.get_size() as _,
                                             ),
                                             mb.as_slice(),
                                         )?;
                                         Zero
                                     }
                                     OutputType::RawObject => {
                                         out.set_extension("raw.o");
-                                        std::fs::write(out, mb.as_slice())?;
+                                        out.create_with_len(mb.get_size() as _)?.write_all(mb.as_slice())?;
                                         Zero
                                     }
                                     OutputType::Object => {
@@ -1858,7 +1862,7 @@ pub fn driver(cli: Cli) -> anyhow::Result<()> {
                                             obj::get_writeable_object_from_file(parsed_llvm_object);
                                         libs::populate_header(&mut writeable_object, &ctx);
                                         let buf = writeable_object.write()?;
-                                        Path::new(&out).write_anyhow(buf)?;
+                                        out.create_with_len(buf.len() as _)?.write_all(&buf)?;
                                         Zero
                                     }
                                     x => unreachable!("{x:?} has already been handled"),

cobalt-llvm/Cargo.toml

@@ -9,8 +9,9 @@ description.workspace = true
 documentation.workspace = true
 
 [dependencies]
-inkwell = { version = "0.2.0", features = ["llvm16-0"] }
-llvm-sys = "160"
+inkwell = { version = "0.2.0" }
+llvm-sys-15 = { package = "llvm-sys", version = "150", optional = true }
+llvm-sys-16 = { package = "llvm-sys", version = "160", optional = true }
 
 [build-dependencies]
 lazy_static = "1.4"
@@ -20,12 +21,15 @@ semver = "1.0"
 
 # features passed to llvm-sys
 [features]
+llvm-15 = ["llvm-sys-15", "inkwell/llvm15-0"]
+llvm-16 = ["llvm-sys-16", "inkwell/llvm16-0"]
+
 default = ["llvm-default"]
-llvm-default = ["strict-versioning", "prefer-dynamic"]
-strict-versioning = ["llvm-sys/strict-versioning"]
-no-llvm-linking = ["llvm-sys/no-llvm-linking"]
+llvm-default = ["llvm-15", "prefer-dynamic"]
+strict-versioning = ["llvm-sys-15?/strict-versioning", "llvm-sys-16?/strict-versioning"]
+no-llvm-linking = ["llvm-sys-15?/no-llvm-linking", "llvm-sys-16?/no-llvm-linking"]
 
-prefer-dynamic = ["llvm-sys/prefer-dynamic"]
-force-dynamic = ["llvm-sys/force-dynamic"]
-prefer-static = ["llvm-sys/prefer-static"]
-force-static = ["llvm-sys/force-static"]
+prefer-dynamic = ["llvm-sys-15?/prefer-dynamic", "llvm-sys-16?/prefer-dynamic"]
+force-dynamic = ["llvm-sys-15?/force-dynamic", "llvm-sys-16?/force-dynamic"]
+prefer-static = ["llvm-sys-15?/prefer-static", "llvm-sys-16?/prefer-static"]
+force-static = ["llvm-sys-15?/force-static", "llvm-sys-16?/force-static"]

cobalt-llvm/build.rs

@@ -1,6 +1,8 @@
 // This file is the same as llvm-sys's, with some slight modifications to make it run as a submodule.
 // Notable changes:
-// - Linking method is prefer-dynamic by default
+// - LLVM version is chosen from features
+// - No linking is actually done here
+// - Cargo variables are set
 // - Small refactors have been made to satisfy Clippy
 
 use const_format::formatcp;
@@ -13,6 +15,9 @@ use std::io::{self, ErrorKind};
 use std::path::PathBuf;
 use std::process::Command;
 
+#[cfg(feature = "llvm-15")]
+const LLVM_MAJOR: u64 = 15;
+#[cfg(feature = "llvm-16")]
 const LLVM_MAJOR: u64 = 16;
 
 // Environment variables that can guide compilation

cobalt-llvm/src/lib.rs

@@ -1,4 +1,10 @@
 pub use inkwell;
-pub use llvm_sys;
+#[cfg(feature = "llvm-15")]
+pub use llvm_sys_15 as llvm_sys;
+#[cfg(feature = "llvm-16")]
+pub use llvm_sys_16 as llvm_sys;
+
+#[cfg(all(feature = "llvm-15", feature = "llvm-16"))]
+compile_error!("LLVM 15 and 16 cannot both be enabled!");
 
 pub const LLVM_VERSION: &str = env!("LLVM_VERSION");