dotscope 0.7.0

A high-performance, cross-platform framework for analyzing and reverse engineering .NET PE executables
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Field (`.field`) directive formatting.
//!
//! Emits ILAsm-compatible `.field` directives including access modifiers, type signatures,
//! marshalling information, field RVA data references, default values, explicit layout
//! offsets, and custom attributes.

use std::io::{self, Write};

use crate::{
    formatting::{
        attributes,
        helpers::{data_label_for_rva, format_constant, format_type_sig, quote_identifier},
        FormatterOptions,
    },
    metadata::{tables::TypeAttributes, typesystem::CilType},
    CilObject,
};

/// Write all `.field` directives for a type's fields.
///
/// Each field is emitted with its full ILAsm syntax including optional explicit
/// layout offset `[N]`, access modifiers, modifier flags (`static`, `initonly`,
/// `literal`), optional `marshal(...)` info, type signature, name, optional
/// `at D_XXXXXXXX` RVA reference, optional `= <value>` default value, and
/// custom attributes.
pub(super) fn format_fields(
    opts: &FormatterOptions,
    w: &mut dyn Write,
    cil_type: &CilType,
    asm: &CilObject,
) -> io::Result<()> {
    let is_explicit_layout = cil_type.flags.layout() == TypeAttributes::EXPLICIT_LAYOUT;

    for (_, field) in cil_type.fields.iter() {
        let flags = field.flags;

        write!(w, "  .field")?;

        // Explicit layout offset
        if is_explicit_layout {
            if let Some(&offset) = field.layout.get() {
                write!(w, " [{offset}]")?;
            }
        }

        // Access
        let kw = flags.access_keyword();
        if !kw.is_empty() {
            write!(w, " {kw}")?;
        }

        // Modifiers
        if flags.is_static() {
            write!(w, " static")?;
        }
        if flags.is_init_only() {
            write!(w, " initonly")?;
        }
        if flags.is_literal() {
            write!(w, " literal")?;
        }
        if flags.is_not_serialized() {
            write!(w, " notserialized")?;
        }
        if flags.is_special_name() {
            write!(w, " specialname")?;
        }
        if flags.is_rt_special_name() {
            write!(w, " rtspecialname")?;
        }

        // Marshal info
        if flags.has_field_marshal() {
            if let Some(marshal) = field.marshal.get() {
                write!(w, " marshal({marshal})")?;
            }
        }

        // Type and name
        write!(
            w,
            " {} {}",
            format_type_sig(&field.signature.base, asm),
            quote_identifier(&field.name)
        )?;

        // Field RVA
        if let Some(&rva) = field.rva.get() {
            let (prefix, _) = data_label_for_rva(asm.file().sections(), rva);
            write!(w, " at {prefix}{rva:08X}")?;
        }

        // Default value (for any field with HAS_DEFAULT, not just literals)
        if flags.has_default() {
            if let Some(default) = field.default.get() {
                write!(w, " = {}", format_constant(default))?;
            }
        }

        writeln!(w)?;

        // Custom attributes on fields
        if opts.show_custom_attributes {
            attributes::format_custom_attributes(w, &field.custom_attributes, "  ", asm)?;
        }
    }
    Ok(())
}