compiler: Use checked catalog dependency slices

db636eec495296b9cebf1723c163ba140621b1adff57357bfbc2074a02887da9
Alexis Sellier committed ago 1 parent f58cc10a
lib/std/arch/rv64/shared/catalog.rad +5 -3
30 30 

    

  
    

      31
      31
       
      
/// View the native bytes of a caller-owned record or array.

    

  
    

      32
      32
       
      
unsafe fn raw(value: &opaque, size: u32) -> *unsafe [u8] { return @sliceOf((value as &u8) as *unsafe u8, size); }

    

  
    

      33
      33
       
      

    

  
    

      34
      34
       
      
/// Obtain a field's byte offset from the compiler's native record layout.

    

  
    

      35
      
      -
      
unsafe fn field(container: &opaque, value: &opaque) -> u32 { return (value as u64 - container as u64) as u32; }

    

  
    

      
      35
      +
      
fn field(container: &opaque, value: &opaque) -> u32 {

    

  
    

      
      36
      +
      
    return (value as u64 - container as u64) as u32;

    

  
    

      
      37
      +
      
}

    

  
    

      36
      38
       
      

    

  
    

      37
      39
       
      
/// Write one little-endian integer into a reserved native field.

    

  
    

      38
      40
       
      
fn integer(output: &mut [u8], offset: u32, value: u64, width: u32) {

    

  
    

      39
      41
       
      
    for i in 0..width {

    

  
    

      40
      42
       
      
        set output[offset + i] = (value >> (i as u64 * 8)) as u8;

    

  
  
  

  
  

  

  
  
    

      54
      56
       
      
    try! mem::copy(&mut output[offset..offset + input.len], input);

    

  
    

      55
      57
       
      
    return offset;

    

  
    

      56
      58
       
      
}

    

  
    

      57
      59
       
      

    

  
    

      58
      60
       
      
/// Copy a dependency list and each name into native catalog storage.

    

  
    

      59
      
      -
      
unsafe fn dependencies(input: *unsafe [*[u8]], base: u64, output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {

    

  
    

      
      61
      +
      
fn dependencies(input: &[*[u8]], base: u64, output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {

    

  
    

      60
      62
       
      
    if input.len > output.len / @sizeOf(*[u8]) {

    

  
    

      61
      63
       
      
        throw shared::Error::Capacity;

    

  
    

      62
      64
       
      
    }

    

  
    

      63
      65
       
      
    let offset = try reserve(output, used, input.len * @sizeOf(*[u8]), @alignOf(*[u8]));

    

  
    

      64
      66
       
      
    for name, i in input {

    

  
  
  

  
  

  

  
  
    

      113
      115
       
      
    for entry, i in entries {

    

  
    

      114
      116
       
      
        let at = i * @sizeOf(Entry);

    

  
    

      115
      117
       
      
        try! mem::copy(&mut output[at..at + @sizeOf(Entry)], raw(&entry, @sizeOf(Entry)));

    

  
    

      116
      118
       
      
        let source = try bytes(entry.source, output, &mut used);

    

  
    

      117
      119
       
      
        let name = try bytes(entry.package.name, output, &mut used);

    

  
    

      118
      
      -
      
        let required = try dependencies(entry.package.dependencies, base, output, &mut used);

    

  
    

      
      120
      +
      
        let required = try dependencies(&entry.package.dependencies[..], base, output, &mut used);

    

  
    

      119
      121
       
      
        let exports = try symbols(entry.package.exports, base, output, &mut used);

    

  
    

      120
      122
       
      
        let template = try bytes(entry.package.template, output, &mut used);

    

  
    

      121
      123
       
      
        let fixups = try relocations(entry.package.relocations, output, &mut used);

    

  
    

      122
      124
       
      
        slice(output, at + field(&entry, &entry.source), base + source as u64, entry.source.len);

    

  
    

      123
      125
       
      
        slice(output, at + field(&entry, &entry.package.name), base + name as u64, entry.package.name.len);