projects / rustc.git / blame
| Commit | Line | Data |
|---|---|---|
| 49aad941 FG |
1 | #![allow(non_snake_case)] |
| 2 | ||
| 3 | use super::*; | |
| 4 | ||
| 5 | #[derive(Default)] | |
| 6 | pub struct Tables { | |
| 7 | pub AssemblyRef: Vec<AssemblyRef>, | |
| 8 | pub ClassLayout: Vec<ClassLayout>, | |
| 9 | pub Constant: Vec<Constant>, | |
| 10 | pub CustomAttribute: Vec<CustomAttribute>, | |
| 11 | pub Field: Vec<Field>, | |
| 12 | pub GenericParam: Vec<GenericParam>, | |
| 13 | pub ImplMap: Vec<ImplMap>, | |
| 14 | pub InterfaceImpl: Vec<InterfaceImpl>, | |
| 15 | pub MemberRef: Vec<MemberRef>, | |
| 16 | pub MethodDef: Vec<MethodDef>, | |
| 17 | pub Module: Vec<Module>, | |
| 18 | pub ModuleRef: Vec<ModuleRef>, | |
| 19 | pub NestedClass: Vec<NestedClass>, | |
| 20 | pub Param: Vec<Param>, | |
| 21 | pub Property: Vec<Property>, | |
| 22 | pub TypeDef: Vec<TypeDef>, | |
| 23 | pub TypeRef: Vec<TypeRef>, | |
| 24 | pub TypeSpec: Vec<TypeSpec>, | |
| 25 | } | |
| 26 | ||
| 27 | #[derive(Default)] | |
| 28 | pub struct AssemblyRef { | |
| 29 | pub MajorVersion: u16, | |
| 30 | pub MinorVersion: u16, | |
| 31 | pub BuildNumber: u16, | |
| 32 | pub RevisionNumber: u16, | |
| 33 | pub Flags: u32, | |
| 34 | pub PublicKeyOrToken: u32, | |
| 35 | pub Name: u32, | |
| 36 | pub Culture: u32, | |
| 37 | pub HashValue: u32, | |
| 38 | } | |
| 39 | ||
| 40 | #[derive(Default)] | |
| 41 | pub struct ClassLayout { | |
| 42 | pub PackingSize: u16, | |
| 43 | pub ClassSize: u32, | |
| 44 | pub Parent: u32, | |
| 45 | } | |
| 46 | ||
| 47 | #[derive(Default)] | |
| 48 | pub struct Constant { | |
| 49 | pub Type: u16, | |
| 50 | pub Parent: u32, | |
| 51 | pub Value: u32, | |
| 52 | } | |
| 53 | ||
| 54 | #[derive(Default)] | |
| 55 | pub struct CustomAttribute { | |
| 56 | pub Parent: u32, | |
| 57 | pub Type: u32, | |
| 58 | pub Value: u32, | |
| 59 | } | |
| 60 | ||
| 61 | #[derive(Default)] | |
| 62 | pub struct Field { | |
| 63 | pub Flags: u16, | |
| 64 | pub Name: u32, | |
| 65 | pub Signature: u32, | |
| 66 | } | |
| 67 | ||
| 68 | #[derive(Default)] | |
| 69 | pub struct GenericParam { | |
| 70 | pub Number: u16, | |
| 71 | pub Flags: u16, | |
| 72 | pub Owner: u32, | |
| 73 | pub Name: u32, | |
| 74 | } | |
| 75 | ||
| 76 | #[derive(Default)] | |
| 77 | pub struct ImplMap { | |
| 78 | pub MappingFlags: u16, | |
| 79 | pub MemberForwarded: u32, | |
| 80 | pub ImportName: u32, | |
| 81 | pub ImportScope: u32, | |
| 82 | } | |
| 83 | ||
| 84 | #[derive(Default)] | |
| 85 | pub struct InterfaceImpl { | |
| 86 | pub Class: u32, | |
| 87 | pub Interface: u32, | |
| 88 | } | |
| 89 | ||
| 90 | #[derive(Default)] | |
| 91 | pub struct MemberRef { | |
| 92 | pub Class: u32, | |
| 93 | pub Name: u32, | |
| 94 | pub Signature: u32, | |
| 95 | } | |
| 96 | ||
| 97 | #[derive(Default)] | |
| 98 | pub struct MethodDef { | |
| 99 | pub RVA: u32, | |
| 100 | pub ImplFlags: u16, | |
| 101 | pub Flags: u16, | |
| 102 | pub Name: u32, | |
| 103 | pub Signature: u32, | |
| 104 | pub ParamList: u32, | |
| 105 | } | |
| 106 | ||
| 107 | #[derive(Default)] | |
| 108 | pub struct Module { | |
| 109 | pub Generation: u16, | |
| 110 | pub Name: u32, | |
| 111 | pub Mvid: u32, | |
| 112 | pub EncId: u32, | |
| 113 | pub EncBaseId: u32, | |
| 114 | } | |
| 115 | ||
| 116 | #[derive(Default)] | |
| 117 | pub struct ModuleRef { | |
| 118 | pub Name: u32, | |
| 119 | } | |
| 120 | ||
| 121 | #[derive(Default)] | |
| 122 | pub struct NestedClass { | |
| 123 | pub NestedClass: u32, | |
| 124 | pub EnclosingClass: u32, | |
| 125 | } | |
| 126 | ||
| 127 | #[derive(Default)] | |
| 128 | pub struct Param { | |
| 129 | pub Flags: u16, | |
| 130 | pub Sequence: u16, | |
| 131 | pub Name: u32, | |
| 132 | } | |
| 133 | ||
| 134 | #[derive(Default)] | |
| 135 | pub struct Property { | |
| 136 | pub Flags: u16, | |
| 137 | pub Name: u32, | |
| 138 | pub Type: u32, | |
| 139 | } | |
| 140 | ||
| 141 | #[derive(Default)] | |
| 142 | pub struct TypeDef { | |
| 143 | pub Flags: u32, | |
| 144 | pub TypeName: u32, | |
| 145 | pub TypeNamespace: u32, | |
| 146 | pub Extends: u32, | |
| 147 | pub FieldList: u32, | |
| 148 | pub MethodList: u32, | |
| 149 | } | |
| 150 | ||
| 151 | #[derive(Default)] | |
| 152 | pub struct TypeRef { | |
| 153 | pub ResolutionScope: u32, | |
| 154 | pub TypeName: u32, | |
| 155 | pub TypeNamespace: u32, | |
| 156 | } | |
| 157 | ||
| 158 | #[derive(Default)] | |
| 159 | pub struct TypeSpec { | |
| 160 | pub Signature: u32, | |
| 161 | } | |
| 162 | ||
| 163 | impl Tables { | |
| 164 | pub fn stream(self) -> Vec<u8> { | |
| 165 | let resolution_scope = coded_index_size(&[self.Module.len(), self.ModuleRef.len(), self.AssemblyRef.len(), self.TypeRef.len()]); | |
| 166 | let type_def_or_ref = coded_index_size(&[self.TypeDef.len(), self.TypeRef.len(), self.TypeSpec.len()]); | |
| 167 | let has_constant = coded_index_size(&[self.Field.len(), self.Param.len(), self.Property.len()]); | |
| 168 | ||
| 169 | let valid_tables: u64 = 1 << 0 | // Module | |
| 170 | 1 << 0x01 | // TypeRef | |
| 171 | 1 << 0x02 | // TypeDef | |
| 172 | 1 << 0x04 | // Field | |
| 173 | 1 << 0x06 | // MethodDef | |
| 174 | 1 << 0x08 | // Param | |
| 175 | 1 << 0x09 | // InterfaceImpl | |
| 176 | 1 << 0x0A | // MemberRef | |
| 177 | 1 << 0x0B | // Constant | |
| 178 | 1 << 0x0C | // CustomAttribute | |
| 179 | 1 << 0x0F | // ClassLayout | |
| 180 | 1 << 0x17 | // Property | |
| 181 | 1 << 0x1A | // ModuleRef | |
| 182 | 1 << 0x1B | // TypeSpec | |
| 183 | 1 << 0x1C | // ImplMap | |
| 184 | 1 << 0x23 | // AssemblyRef | |
| 185 | 1 << 0x29 | // NestedClass | |
| 186 | 1 << 0x2A; // GenericParam | |
| 187 | ||
| 188 | // The table stream header... | |
| 189 | ||
| 190 | let mut buffer = Vec::new(); | |
| 191 | buffer.write_u32(0); // Reserved | |
| 192 | buffer.write_u8(2); // MajorVersion | |
| 193 | buffer.write_u8(0); // MinorVersion | |
| 194 | buffer.write_u8(0b111); // HeapSizes | |
| 195 | buffer.write_u8(0); // Reserved | |
| 196 | buffer.write_u64(valid_tables); | |
| 197 | buffer.write_u64(0); // Sorted | |
| 198 | ||
| 199 | // Followed by the length of each of the valid tables... | |
| 200 | ||
| 201 | buffer.write_u32(self.Module.len() as u32); | |
| 202 | buffer.write_u32(self.TypeRef.len() as u32); | |
| 203 | buffer.write_u32(self.TypeDef.len() as u32); | |
| 204 | buffer.write_u32(self.Field.len() as u32); | |
| 205 | buffer.write_u32(self.MethodDef.len() as u32); | |
| 206 | buffer.write_u32(self.Param.len() as u32); | |
| 207 | buffer.write_u32(self.InterfaceImpl.len() as u32); | |
| 208 | buffer.write_u32(self.MemberRef.len() as u32); | |
| 209 | buffer.write_u32(self.Constant.len() as u32); | |
| 210 | buffer.write_u32(self.CustomAttribute.len() as u32); | |
| 211 | buffer.write_u32(self.ClassLayout.len() as u32); | |
| 212 | buffer.write_u32(self.Property.len() as u32); | |
| 213 | buffer.write_u32(self.ModuleRef.len() as u32); | |
| 214 | buffer.write_u32(self.TypeSpec.len() as u32); | |
| 215 | buffer.write_u32(self.ImplMap.len() as u32); | |
| 216 | buffer.write_u32(self.AssemblyRef.len() as u32); | |
| 217 | buffer.write_u32(self.NestedClass.len() as u32); | |
| 218 | buffer.write_u32(self.GenericParam.len() as u32); | |
| 219 | ||
| 220 | // Followed by each table's rows... | |
| 221 | ||
| 222 | for x in self.Module { | |
| 223 | buffer.write_u16(x.Generation); | |
| 224 | buffer.write_u32(x.Name); | |
| 225 | buffer.write_u32(x.Mvid); | |
| 226 | buffer.write_u32(x.EncId); | |
| 227 | buffer.write_u32(x.EncBaseId); | |
| 228 | } | |
| 229 | ||
| 230 | for x in self.TypeRef { | |
| 231 | buffer.write_code(x.ResolutionScope, resolution_scope); | |
| 232 | buffer.write_u32(x.TypeName); | |
| 233 | buffer.write_u32(x.TypeNamespace); | |
| 234 | } | |
| 235 | ||
| 236 | for x in self.TypeDef { | |
| 237 | buffer.write_u32(x.Flags); | |
| 238 | buffer.write_u32(x.TypeName); | |
| 239 | buffer.write_u32(x.TypeNamespace); | |
| 240 | buffer.write_code(x.Extends, type_def_or_ref); | |
| 241 | buffer.write_index(x.FieldList, self.Field.len()); | |
| 242 | buffer.write_index(x.MethodList, self.MethodDef.len()); | |
| 243 | } | |
| 244 | ||
| 245 | for x in self.Field { | |
| 246 | buffer.write_u16(x.Flags); | |
| 247 | buffer.write_u32(x.Name); | |
| 248 | buffer.write_u32(x.Signature); | |
| 249 | } | |
| 250 | ||
| 251 | for x in self.MethodDef { | |
| 252 | buffer.write_u32(x.RVA); | |
| 253 | buffer.write_u16(x.ImplFlags); | |
| 254 | buffer.write_u16(x.Flags); | |
| 255 | buffer.write_u32(x.Name); | |
| 256 | buffer.write_u32(x.Signature); | |
| 257 | buffer.write_index(x.ParamList, self.Param.len()); | |
| 258 | } | |
| 259 | ||
| 260 | for x in self.Param { | |
| 261 | buffer.write_u16(x.Flags); | |
| 262 | buffer.write_u16(x.Sequence); | |
| 263 | buffer.write_u32(x.Name); | |
| 264 | } | |
| 265 | ||
| 266 | for x in self.Constant { | |
| 267 | buffer.write_u16(x.Type); | |
| 268 | buffer.write_code(x.Parent, has_constant); | |
| 269 | buffer.write_u32(x.Value); | |
| 270 | } | |
| 271 | ||
| 272 | for x in self.AssemblyRef { | |
| 273 | buffer.write_u16(x.MajorVersion); | |
| 274 | buffer.write_u16(x.MinorVersion); | |
| 275 | buffer.write_u16(x.BuildNumber); | |
| 276 | buffer.write_u16(x.RevisionNumber); | |
| 277 | buffer.write_u32(x.Flags); | |
| 278 | buffer.write_u32(x.PublicKeyOrToken); | |
| 279 | buffer.write_u32(x.Name); | |
| 280 | buffer.write_u32(x.Culture); | |
| 281 | buffer.write_u32(x.HashValue); | |
| 282 | } | |
| 283 | ||
| 284 | buffer.resize(round(buffer.len(), 4), 0); | |
| 285 | buffer | |
| 286 | } | |
| 287 | } |