Struct BlockIter 

pub struct BlockIter<'global_state, 'input> {
    pub id: u32,
    /* private fields */
}

Iterator content directly in a block

Fields

id: u32

ID of the block being iterated

Implementations

impl<'global_state, 'input> BlockIter<'global_state, 'input>

pub fn next_record<'parent>( &'parent mut self, ) -> Result<Option<RecordIter<'parent, 'input>>, Error>

pub fn next<'parent>( &'parent mut self, ) -> Result<Option<BlockItem<'parent, 'input>>, Error>

Returns the next item (block or record) in this block

Examples found in repository

examples/llvm_bca.rs (line 27)

fn iter_block(mut block: BlockIter, depth: usize) -> Result<(), Error> {
    let outer_block_id = block.id;
    while let Some(b) = block.next()? {
        match b {
            BlockItem::Block(b) => {
                let tag_name = block_tag_name(b.id as _);
                println!(
                    "{:indent$}<{tag_name} NumWords={nw} BlockCodeSize={ab}>",
                    "",
                    nw = b.debug_data_len().unwrap_or(0) / 4,
                    ab = b.debug_abbrev_width(),
                    indent = depth * 2
                );
                iter_block(b, depth + 1)?;
                println!("{:indent$}</{tag_name}>", "", indent = depth * 2);
            }
            BlockItem::Record(mut r) => {
                let tag_name = record_tag_name(outer_block_id as _, r.id as _);
                print!("{:indent$}<{tag_name}", "", indent = depth * 2);
                if let Some(a) = r.debug_abbrev_id() {
                    print!(" abbrevid={a}");
                }
                let fields = r
                    .by_ref()
                    .map(|f| f.map(|f| f as i64))
                    .collect::<Result<Vec<_>, _>>()?;
                for (i, &op) in fields.iter().enumerate() {
                    print!(" op{i}={op}");
                }
                let payload: Result<_, _> = r.payload();
                match payload {
                    Ok(Some(llvm_bitcode::bitcode::Payload::Array(a))) => {
                        for (i, op) in a.iter().enumerate() {
                            print!(" op{}={op}", i + fields.len());
                        }
                        if !a.is_empty() && a.iter().all(|&c| (c as u8) >= 0x20 && (c as u8) < 0x7F)
                        {
                            // lol bug in the original
                            let s: String = a.iter().map(|&c| c as u8 as char).collect();
                            println!("/> record string = '{s}'");
                        } else {
                            println!("/>");
                        }
                    }
                    Ok(Some(llvm_bitcode::bitcode::Payload::Char6String(s))) => {
                        for (i, op) in s.chars().enumerate() {
                            print!(" op{}={}", i + fields.len(), op as u32);
                        }
                        if s.is_empty() {
                            println!("/>");
                        } else {
                            println!("/> record string = '{s}'");
                        }
                    }
                    Ok(None) => {
                        if r.debug_abbrev_id().is_some()
                            && fields.len() > 1
                            && fields.iter().skip(1).all(|&c| (0x20..0x7F).contains(&c))
                        {
                            let s: String =
                                fields.iter().skip(1).map(|&c| c as u8 as char).collect();
                            println!("/> record string = '{s}'");
                        } else {
                            println!("/>");
                        }
                    }
                    Ok(Some(llvm_bitcode::bitcode::Payload::Blob(b))) => {
                        if b.len() < 10000 && b.iter().all(|&c| (0x20..0x7F).contains(&c)) {
                            println!("/> blob data = {}", String::from_utf8_lossy(&b));
                        } else {
                            print!("/> blob data = ");
                            if b.len() > 50 {
                                print!("unprintable, {} bytes.", b.len());
                            } else {
                                print!("'");
                                for b in b {
                                    print!("{b:02x}");
                                }
                                print!("'");
                            }
                            println!();
                        }
                    }
                    Err(err) => print!("/> payload_err={err}"),
                }
            }
        }
    }
    Ok(())
}

pub fn debug_abbrev_width(&self) -> u8

Bit width of abbreviation IDs in this block.

This is an implementation detail, intended only for debugging or data dumps.

Examples found in repository

examples/llvm_bca.rs (line 35)

fn iter_block(mut block: BlockIter, depth: usize) -> Result<(), Error> {
    let outer_block_id = block.id;
    while let Some(b) = block.next()? {
        match b {
            BlockItem::Block(b) => {
                let tag_name = block_tag_name(b.id as _);
                println!(
                    "{:indent$}<{tag_name} NumWords={nw} BlockCodeSize={ab}>",
                    "",
                    nw = b.debug_data_len().unwrap_or(0) / 4,
                    ab = b.debug_abbrev_width(),
                    indent = depth * 2
                );
                iter_block(b, depth + 1)?;
                println!("{:indent$}</{tag_name}>", "", indent = depth * 2);
            }
            BlockItem::Record(mut r) => {
                let tag_name = record_tag_name(outer_block_id as _, r.id as _);
                print!("{:indent$}<{tag_name}", "", indent = depth * 2);
                if let Some(a) = r.debug_abbrev_id() {
                    print!(" abbrevid={a}");
                }
                let fields = r
                    .by_ref()
                    .map(|f| f.map(|f| f as i64))
                    .collect::<Result<Vec<_>, _>>()?;
                for (i, &op) in fields.iter().enumerate() {
                    print!(" op{i}={op}");
                }
                let payload: Result<_, _> = r.payload();
                match payload {
                    Ok(Some(llvm_bitcode::bitcode::Payload::Array(a))) => {
                        for (i, op) in a.iter().enumerate() {
                            print!(" op{}={op}", i + fields.len());
                        }
                        if !a.is_empty() && a.iter().all(|&c| (c as u8) >= 0x20 && (c as u8) < 0x7F)
                        {
                            // lol bug in the original
                            let s: String = a.iter().map(|&c| c as u8 as char).collect();
                            println!("/> record string = '{s}'");
                        } else {
                            println!("/>");
                        }
                    }
                    Ok(Some(llvm_bitcode::bitcode::Payload::Char6String(s))) => {
                        for (i, op) in s.chars().enumerate() {
                            print!(" op{}={}", i + fields.len(), op as u32);
                        }
                        if s.is_empty() {
                            println!("/>");
                        } else {
                            println!("/> record string = '{s}'");
                        }
                    }
                    Ok(None) => {
                        if r.debug_abbrev_id().is_some()
                            && fields.len() > 1
                            && fields.iter().skip(1).all(|&c| (0x20..0x7F).contains(&c))
                        {
                            let s: String =
                                fields.iter().skip(1).map(|&c| c as u8 as char).collect();
                            println!("/> record string = '{s}'");
                        } else {
                            println!("/>");
                        }
                    }
                    Ok(Some(llvm_bitcode::bitcode::Payload::Blob(b))) => {
                        if b.len() < 10000 && b.iter().all(|&c| (0x20..0x7F).contains(&c)) {
                            println!("/> blob data = {}", String::from_utf8_lossy(&b));
                        } else {
                            print!("/> blob data = ");
                            if b.len() > 50 {
                                print!("unprintable, {} bytes.", b.len());
                            } else {
                                print!("'");
                                for b in b {
                                    print!("{b:02x}");
                                }
                                print!("'");
                            }
                            println!();
                        }
                    }
                    Err(err) => print!("/> payload_err={err}"),
                }
            }
        }
    }
    Ok(())
}

pub fn debug_data_len(&self) -> Option<usize>

Valid only before any record or subblock has been read. This is the block size in bytes.

This is an implementation detail, intended only for debugging or data dumps.

Examples found in repository

examples/llvm_bca.rs (line 34)

fn iter_block(mut block: BlockIter, depth: usize) -> Result<(), Error> {
    let outer_block_id = block.id;
    while let Some(b) = block.next()? {
        match b {
            BlockItem::Block(b) => {
                let tag_name = block_tag_name(b.id as _);
                println!(
                    "{:indent$}<{tag_name} NumWords={nw} BlockCodeSize={ab}>",
                    "",
                    nw = b.debug_data_len().unwrap_or(0) / 4,
                    ab = b.debug_abbrev_width(),
                    indent = depth * 2
                );
                iter_block(b, depth + 1)?;
                println!("{:indent$}</{tag_name}>", "", indent = depth * 2);
            }
            BlockItem::Record(mut r) => {
                let tag_name = record_tag_name(outer_block_id as _, r.id as _);
                print!("{:indent$}<{tag_name}", "", indent = depth * 2);
                if let Some(a) = r.debug_abbrev_id() {
                    print!(" abbrevid={a}");
                }
                let fields = r
                    .by_ref()
                    .map(|f| f.map(|f| f as i64))
                    .collect::<Result<Vec<_>, _>>()?;
                for (i, &op) in fields.iter().enumerate() {
                    print!(" op{i}={op}");
                }
                let payload: Result<_, _> = r.payload();
                match payload {
                    Ok(Some(llvm_bitcode::bitcode::Payload::Array(a))) => {
                        for (i, op) in a.iter().enumerate() {
                            print!(" op{}={op}", i + fields.len());
                        }
                        if !a.is_empty() && a.iter().all(|&c| (c as u8) >= 0x20 && (c as u8) < 0x7F)
                        {
                            // lol bug in the original
                            let s: String = a.iter().map(|&c| c as u8 as char).collect();
                            println!("/> record string = '{s}'");
                        } else {
                            println!("/>");
                        }
                    }
                    Ok(Some(llvm_bitcode::bitcode::Payload::Char6String(s))) => {
                        for (i, op) in s.chars().enumerate() {
                            print!(" op{}={}", i + fields.len(), op as u32);
                        }
                        if s.is_empty() {
                            println!("/>");
                        } else {
                            println!("/> record string = '{s}'");
                        }
                    }
                    Ok(None) => {
                        if r.debug_abbrev_id().is_some()
                            && fields.len() > 1
                            && fields.iter().skip(1).all(|&c| (0x20..0x7F).contains(&c))
                        {
                            let s: String =
                                fields.iter().skip(1).map(|&c| c as u8 as char).collect();
                            println!("/> record string = '{s}'");
                        } else {
                            println!("/>");
                        }
                    }
                    Ok(Some(llvm_bitcode::bitcode::Payload::Blob(b))) => {
                        if b.len() < 10000 && b.iter().all(|&c| (0x20..0x7F).contains(&c)) {
                            println!("/> blob data = {}", String::from_utf8_lossy(&b));
                        } else {
                            print!("/> blob data = ");
                            if b.len() > 50 {
                                print!("unprintable, {} bytes.", b.len());
                            } else {
                                print!("'");
                                for b in b {
                                    print!("{b:02x}");
                                }
                                print!("'");
                            }
                            println!();
                        }
                    }
                    Err(err) => print!("/> payload_err={err}"),
                }
            }
        }
    }
    Ok(())
}

Trait Implementations

impl<'global_state, 'input> Debug for BlockIter<'global_state, 'input>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.