![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cvinfo.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / symedit|
Return to cvinfo.h CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / symedit |
1.1 root 1: /*** cvinfo.h - Generic CodeView information definitions
2: *
3: * Structures, constants, etc. for accessing and interpreting
4: * CodeView information.
5: *
6: */
7:
8:
9: /*** Disclaimer
10: *
11: * Information in this header file is subject to change without notice
12: * and does not represent a commitment on the part of Microsoft Corporation
13: * to support or maintain this information in future versions of the
14: * software.
15: *
16: * These contents may become obsolete in the future.
17: *
18: */
19:
20:
21: #ifndef _CV_INFO_INCLUDED
22: #define _CV_INFO_INCLUDED
23:
24: #pragma pack(1)
25: typedef unsigned long CV_uoff32_t;
26: typedef long CV_off32_t;
27: typedef unsigned short CV_uoff16_t;
28: typedef short CV_off16_t;
29: typedef unsigned short CV_typ_t;
30:
31:
32:
33: #ifdef _REAL10
34: typedef struct {
35: char b[10];
36: } REAL10;
37: #endif
38:
39: #define CV_SIGNATURE_C6 0L /* Actual signature is >64K */
40: #define CV_SIGNATURE_C7 1L /* First explicit signature */
41: #define CV_SIGNATURE_RESERVED 2L /* All signatures from 2 to 64K are reserved */
42:
43: #define CV_MAXOFFSET 0xffffffff
44:
45: /** CodeView Symbol and Type OMF type information is broken up into two
46: * ranges. Type indices less than 0x1000 describe frequently used
47: * type information that is frequently used. Type indices above
48: * 0x1000 are used to describe more complex features such as function,
49: * arrays and structures.
50: */
51:
52:
53:
54:
55: /** Primitive types have predefined meaning that is encoded in the
56: * values of the various bit fields in the value.
57: *
58: * A CodeView primitive type is defined as:
59: *
60: * 1 1
61: * 1 089 7654 3 210
62: * r mode type r sub
63: *
64: * Where
65: * mode is the pointer mode
66: * type is a type indicator
67: * sub is a subtype enumeration
68: * r is a reserved field
69: *
70: * See Microsoft Symbol and Type OMF (Version 4.0) for more
71: * information.
72: */
73:
74:
75: #define CV_MMASK 0x700 /* mode mask */
76: #define CV_TMASK 0x0f0 /* type mask */
77: #define CV_SMASK 0x007 /* subtype mask */
78:
79: #define CV_MSHIFT 8 /* primitive mode right shift count */
80: #define CV_TSHIFT 4 /* primitive type right shift count */
81: #define CV_SSHIFT 0 /* primitive subtype right shift count */
82:
83: /*
84: * macros to extract primitive mode, type and size
85: */
86:
87: #define CV_MODE(typ) (((typ) & CV_MMASK) >> CV_MSHIFT)
88: #define CV_TYPE(typ) (((typ) & CV_TMASK) >> CV_TSHIFT)
89: #define CV_SUBT(typ) (((typ) & CV_SMASK) >> CV_SSHIFT)
90:
91: /*
92: * macros to insert new primitive mode, type and size
93: */
94:
95: #define CV_NEWMODE(typ, nm) (((typ) & ~CV_MMASK) | ((nm) << CV_MSHIFT))
96: #define CV_NEWTYPE(typ, nt) (((typ) & ~CV_TMASK) | ((nt) << CV_TSHIFT))
97: #define CV_NEWSUBT(typ, ns) (((typ) & ~CV_SMASK) | ((ns) << CV_SSHIFT))
98:
99: /*
100: * pointer mode enumeration values
101: */
102:
103: typedef enum CV_prmode_e {
104: CV_TM_DIRECT = 0, /* mode is not a pointer */
105: CV_TM_NPTR = 1, /* mode is a near pointer */
106: CV_TM_FPTR = 2, /* mode is a far pointer */
107: CV_TM_HPTR = 3, /* mode is a huge pointer */
108: CV_TM_NPTR32 = 4, /* mode is a 32 bit near pointer */
109: CV_TM_FPTR32 = 5, /* mode is a 32 bit far pointer */
110: CV_TM_NPTR64 = 6 /* mode is a 64 bit near pointer */
111: } CV_prmode_e;
112:
113: /*
114: * type enumeration values
115: */
116:
117: typedef enum CV_type_e {
118: CV_SPECIAL = 0x00, /* special type size values */
119: CV_SIGNED = 0x01, /* signed integral size values */
120: CV_UNSIGNED = 0x02, /* unsigned integral size values */
121: CV_BOOLEAN = 0x03, /* Boolean size values */
122: CV_REAL = 0x04, /* real number size values */
123: CV_COMPLEX = 0x05, /* complex number size values */
124: CV_SPECIAL2 = 0x06, /* second set of special types */
125: CV_INT = 0x07, /* integral (int) values */
126: CV_CVRESERVED = 0x0f
127: } CV_type_e;
128:
129: /*
130: * subtype enumeration values for CV_SPECIAL
131: */
132:
133: typedef enum CV_special_e {
134: CV_SP_NOTYPE = 0x00,
135: CV_SP_ABS = 0x01,
136: CV_SP_SEGMENT = 0x02,
137: CV_SP_VOID = 0x03,
138: CV_SP_CURRENCY = 0x04,
139: CV_SP_NBASICSTR = 0x05,
140: CV_SP_FBASICSTR = 0x06,
141: CV_SP_NOTTRANS = 0x07
142: } CV_special_e;
143:
144: /*
145: * subtype enumeration values for CV_SPECIAL2
146: */
147:
148:
149: typedef enum CV_special2_e {
150: CV_S2_BIT = 0x00,
151: CV_S2_PASCHAR = 0x01 /* Pascal CHAR */
152: } CV_special2_e;
153:
154: /*
155: * subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOOLEAN
156: */
157:
158: typedef enum CV_integral_e {
159: CV_IN_1BYTE = 0x00,
160: CV_IN_2BYTE = 0x01,
161: CV_IN_4BYTE = 0x02,
162: CV_IN_8BYTE = 0x03
163: } CV_integral_e;
164:
165: /*
166: * subtype enumeration values for CV_REAL and CV_COMPLEX
167: */
168:
169: typedef enum CV_real_e {
170: CV_RC_REAL32 = 0x00,
171: CV_RC_REAL64 = 0x01,
172: CV_RC_REAL80 = 0x02,
173: CV_RC_REAL128 = 0x03,
174: CV_RC_REAL48 = 0x04
175: } CV_real_e;
176:
177: /*
178: * subtype enumeration values for CV_INT (really int)
179: */
180:
181: typedef enum CV_int_e {
182: CV_RI_CHAR = 0x00,
183: CV_RI_WCHAR = 0x01,
184: CV_RI_INT2 = 0x02,
185: CV_RI_UINT2 = 0x03,
186: CV_RI_INT4 = 0x04,
187: CV_RI_UINT4 = 0x05,
188: CV_RI_INT8 = 0x06,
189: CV_RI_UINT8 = 0x07
190: } CV_int_e;
191:
192: /*
193: * macros to check the type of a primitive
194: */
195:
196: #define CV_TYP_IS_DIRECT(typ) (CV_MODE(typ) == CV_TM_DIRECT)
197: #define CV_TYP_IS_PTR(typ) (CV_MODE(typ) != CV_TM_DIRECT)
198: #define CV_TYP_IS_NPTR(typ) (CV_MODE(typ) == CV_TM_NPTR)
199: #define CV_TYP_IS_FPTR(typ) (CV_MODE(typ) == CV_TM_FPTR)
200: #define CV_TYP_IS_HPTR(typ) (CV_MODE(typ) == CV_TM_HPTR)
201: #define CV_TYP_IS_NPTR32(typ) (CV_MODE(typ) == CV_TM_NPTR32)
202: #define CV_TYP_IS_FPTR32(typ) (CV_MODE(typ) == CV_TM_FPTR32)
203:
204: #define CV_TYP_IS_SIGNED(typ) (((CV_TYPE(typ) == CV_SIGNED) && \
205: CV_TYP_IS_DIRECT(typ)) || \
206: (typ == T_INT2) || \
207: (typ == T_INT4) || \
208: (typ == T_INT8) || \
209: (typ == T_RCHAR))
210:
211: #define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) == CV_UNSIGNED) && \
212: CV_TYP_IS_DIRECT(typ)) || \
213: (typ == T_UINT2) || \
214: (typ == T_UINT4) || \
215: (typ == T_UINT8) || \
216: (typ == T_RCHAR))
217:
218: #define CV_TYP_IS_REAL(typ) ((CV_TYPE(typ) == CV_REAL) && CV_TYP_IS_DIRECT(typ))
219:
220: #define CV_FIRST_NONPRIM 0x1000
221: #define CV_IS_PRIMITIVE(typ) ((typ) < CV_FIRST_NONPRIM)
222:
223:
224:
225: /*
226: * selected values for type_index - for a more complete definition, see
227: * Microsoft Symbol and Type OMF document
228: */
229:
230: /*
231: * Special Types
232: */
233:
234: #define T_NOTYPE 0x0000 /* uncharacterized type (no type) */
235: #define T_ABS 0x0001 /* absolute symbol */
236: #define T_SEGMENT 0x0002 /* segment type */
237: #define T_VOID 0x0003 /* void */
238: #define T_PVOID 0x0103 /* near pointer to void */
239: #define T_PFVOID 0x0203 /* far pointer to void */
240: #define T_PHVOID 0x0303 /* huge pointer to void */
241: #define T_32PVOID 0x0403 /* 16:32 near pointer to void */
242: #define T_32PFVOID 0x0503 /* 16:32 far pointer to void */
243: #define T_CURRENCY 0x0004 /* BASIC 8 byte currency value */
244: #define T_NBASICSTR 0x0005 /* Near BASIC string */
245: #define T_FBASICSTR 0x0006 /* Far BASIC string */
246: #define T_NOTTRANS 0x0007 /* type not translated by cvpack */
247: #define T_BIT 0x0060 /* bit */
248: #define T_PASCHAR 0x0061 /* Pascal CHAR */
249:
250: /*
251: * Character types
252: */
253:
254: #define T_CHAR 0x0010 /* 8 bit signed */
255: #define T_UCHAR 0x0020 /* 8 bit unsigned */
256: #define T_PCHAR 0x0110 /* near pointer to 8 bit signed */
257: #define T_PUCHAR 0x0120 /* near pointer to 8 bit unsigned */
258: #define T_PFCHAR 0x0210 /* far pointer to 8 bit signed */
259: #define T_PFUCHAR 0x0220 /* far pointer to 8 bit unsigned */
260: #define T_PHCHAR 0x0310 /* huge pointer to 8 bit signed */
261: #define T_PHUCHAR 0x0320 /* huge pointer to 8 bit unsigned */
262: #define T_32PCHAR 0x0410 /* 16:32 near pointer to 8 bit signed */
263: #define T_32PUCHAR 0x0420 /* 16:32 near pointer to 8 bit unsigned */
264: #define T_32PFCHAR 0x0510 /* 16:32 far pointer to 8 bit signed */
265: #define T_32PFUCHAR 0x0520 /* 16:32 far pointer to 8 bit unsigned */
266:
267: /*
268: * really a character types
269: */
270:
271: #define T_RCHAR 0x0070 /* really a char */
272: #define T_PRCHAR 0x0170 /* 16:16 near pointer to a real char */
273: #define T_PFRCHAR 0x0270 /* 16:16 far pointer to a real char */
274: #define T_PHRCHAR 0x0370 /* 16:16 huge pointer to a real char */
275: #define T_32PRCHAR 0x0470 /* 16:32 near pointer to a real char */
276: #define T_32PFRCHAR 0x0570 /* 16:32 far pointer to a real char */
277:
278: /*
279: * really a wide character types (UNICODE)
280: */
281:
282: #define T_WCHAR 0x0071 /* wide char */
283: #define T_PWCHAR 0x0171 /* 16:16 near pointer to a wide char */
284: #define T_PFWCHAR 0x0271 /* 16:16 far pointer to a wide char */
285: #define T_PHWCHAR 0x0371 /* 16:16 huge pointer to a wide char */
286: #define T_32PWCHAR 0x0471 /* 16:32 near pointer to a wide char */
287: #define T_32PFWCHAR 0x0571 /* 16:32 far pointer to a wide char */
288:
289: /*
290: * 16 bit short types
291: */
292:
293: #define T_SHORT 0x0011 /* 16 bit signed */
294: #define T_USHORT 0x0021 /* 16 bit unsigned */
295: #define T_PSHORT 0x0111 /* near pointer to 16 bit signed */
296: #define T_PUSHORT 0x0121 /* near pointer to 16 bit unsigned */
297: #define T_PFSHORT 0x0211 /* far pointer to 16 bit signed */
298: #define T_PFUSHORT 0x0221 /* far pointer to 16 bit unsigned */
299: #define T_PHSHORT 0x0311 /* huge pointer to 16 bit signed */
300: #define T_PHUSHORT 0x0321 /* huge pointer to 16 bit unsigned */
301:
302: #define T_32PSHORT 0x0411 /* 16:32 near pointer to 16 bit signed */
303: #define T_32PUSHORT 0x0421 /* 16:32 near pointer to 16 bit unsigned */
304: #define T_32PFSHORT 0x0511 /* 16:32 far pointer to 16 bit signed */
305: #define T_32PFUSHORT 0x0521 /* 16:32 far pointer to 16 bit unsigned */
306:
307: /*
308: * 16 bit int types
309: */
310:
311: #define T_INT2 0x0072 /* 16 bit signed int */
312: #define T_UINT2 0x0073 /* 16 bit unsigned int */
313: #define T_PINT2 0x0172 /* near pointer to 16 bit signed int */
314: #define T_PUINT2 0x0173 /* near pointer to 16 bit unsigned int */
315: #define T_PFINT2 0x0272 /* far pointer to 16 bit signed int */
316: #define T_PFUINT2 0x0273 /* far pointer to 16 bit unsigned int */
317: #define T_PHINT2 0x0372 /* huge pointer to 16 bit signed int */
318: #define T_PHUINT2 0x0373 /* huge pointer to 16 bit unsigned int */
319:
320: #define T_32PINT2 0x0472 /* 16:32 near pointer to 16 bit signed int */
321: #define T_32PUINT2 0x0473 /* 16:32 near pointer to 16 bit unsigned int */
322: #define T_32PFINT2 0x0572 /* 16:32 far pointer to 16 bit signed int */
323: #define T_32PFUINT2 0x0573 /* 16:32 far pointer to 16 bit unsigned int */
324:
325: /*
326: * 32 bit long types
327: */
328:
329: #define T_LONG 0x0012 /* 32 bit signed */
330: #define T_ULONG 0x0022 /* 32 bit unsigned */
331: #define T_PLONG 0x0112 /* near pointer to 32 bit signed */
332: #define T_PLONG 0x0112 /* near pointer to 32 bit signed */
333: #define T_PULONG 0x0122 /* near pointer to 32 bit unsigned */
334: #define T_PFLONG 0x0212 /* far pointer to 32 bit signed */
335: #define T_PFULONG 0x0222 /* far pointer to 32 bit unsigned */
336: #define T_PHLONG 0x0312 /* huge pointer to 32 bit signed */
337: #define T_PHULONG 0x0322 /* huge pointer to 32 bit unsigned */
338:
339: #define T_32PLONG 0x0412 /* 16:32 near pointer to 32 bit signed */
340: #define T_32PULONG 0x0422 /* 16:32 near pointer to 32 bit unsigned */
341: #define T_32PFLONG 0x0512 /* 16:32 far pointer to 32 bit signed */
342: #define T_32PFULONG 0x0522 /* 16:32 far pointer to 32 bit unsigned */
343:
344: /*
345: * 32 bit int types
346: */
347:
348: #define T_INT4 0x0074 /* 32 bit signed int */
349: #define T_UINT4 0x0075 /* 32 bit unsigned int */
350: #define T_PINT4 0x0174 /* near pointer to 32 bit signed int */
351: #define T_PUINT4 0x0175 /* near pointer to 32 bit unsigned int */
352: #define T_PFINT4 0x0274 /* far pointer to 32 bit signed int */
353: #define T_PFUINT4 0x0275 /* far pointer to 32 bit unsigned int */
354: #define T_PHINT4 0x0374 /* huge pointer to 32 bit signed int */
355: #define T_PHUINT4 0x0375 /* huge pointer to 32 bit unsigned int */
356:
357: #define T_32PINT4 0x0474 /* 16:32 near pointer to 32 bit signed int */
358: #define T_32PUINT4 0x0475 /* 16:32 near pointer to 32 bit unsigned int */
359: #define T_32PFINT4 0x0574 /* 16:32 far pointer to 32 bit signed int */
360: #define T_32PFUINT4 0x0575 /* 16:32 far pointer to 32 bit unsigned int */
361:
362: /*
363: * 64 bit quad types
364: */
365:
366:
367: #define T_QUAD 0x0013 /* 64 bit signed */
368: #define T_UQUAD 0x0023 /* 64 bit unsigned */
369: #define T_PQUAD 0x0113 /* near pointer to 64 bit signed */
370: #define T_PUQUAD 0x0123 /* near pointer to 64 bit unsigned */
371: #define T_PFQUAD 0x0213 /* far pointer to 64 bit signed */
372: #define T_PFUQUAD 0x0223 /* far pointer to 64 bit unsigned */
373: #define T_PHQUAD 0x0313 /* huge pointer to 64 bit signed */
374: #define T_PHUQUAD 0x0323 /* huge pointer to 64 bit unsigned */
375:
376: /*
377: * 64 bit int types
378: */
379:
380: #define T_INT8 0x0076 /* 64 bit signed int */
381: #define T_UINT8 0x0077 /* 64 bit unsigned int */
382: #define T_PINT8 0x0176 /* near pointer to 64 bit signed int */
383: #define T_PUINT8 0x0177 /* near pointer to 64 bit unsigned int */
384: #define T_PFINT8 0x0276 /* far pointer to 64 bit signed int */
385: #define T_PFUINT8 0x0277 /* far pointer to 64 bit unsigned int */
386: #define T_PHINT8 0x0376 /* huge pointer to 64 bit signed int */
387: #define T_PHUINT8 0x0377 /* huge pointer to 64 bit unsigned int */
388:
389: #define T_32PINT8 0x0476 /* 16:32 near pointer to 64 bit signed int */
390: #define T_32PUINT8 0x0477 /* 16:32 near pointer to 64 bit unsigned int */
391: #define T_32PFINT8 0x0576 /* 16:32 far pointer to 64 bit signed int */
392: #define T_32PFUINT8 0x0577 /* 16:32 far pointer to 64 bit unsigned int */
393:
394: /*
395: * 32 bit real types
396: */
397:
398: #define T_REAL32 0x0040 /* 32 bit real */
399: #define T_PREAL32 0x0140 /* near pointer to 32 bit real */
400: #define T_PFREAL32 0x0240 /* far pointer to 32 bit real */
401: #define T_PHREAL32 0x0340 /* huge pointer to 32 bit real */
402: #define T_32PREAL32 0x0440 /* 16:32 near pointer to 32 bit real */
403: #define T_32PFREAL32 0x0540 /* 16:32 far pointer to 32 bit real */
404:
405: /*
406: * 48 bit real types
407: */
408:
409: #define T_REAL48 0x0044 /* 48 bit real */
410: #define T_PREAL48 0x0144 /* near pointer to 48 bit real */
411: #define T_PFREAL48 0x0244 /* far pointer to 48 bit real */
412: #define T_PHREAL48 0x0344 /* huge pointer to 48 bit real */
413: #define T_32PREAL48 0x0444 /* 16:32 near pointer to 48 bit real */
414: #define T_32PFREAL48 0x0544 /* 16:32 far pointer to 48 bit real */
415:
416: /*
417: * 64 bit real types
418: */
419:
420: #define T_REAL64 0x0041 /* 64 bit real */
421: #define T_PREAL64 0x0141 /* near pointer to 64 bit real */
422: #define T_PFREAL64 0x0241 /* far pointer to 64 bit real */
423: #define T_PHREAL64 0x0341 /* huge pointer to 64 bit real */
424: #define T_32PREAL64 0x0441 /* 16:32 near pointer to 64 bit real */
425: #define T_32PFREAL64 0x0541 /* 16:32 far pointer to 64 bit real */
426:
427: /*
428: * 80 bit real types
429: */
430:
431: #define T_REAL80 0x0042 /* 80 bit real */
432: #define T_PREAL80 0x0142 /* near pointer to 80 bit real */
433: #define T_PFREAL80 0x0242 /* far pointer to 80 bit real */
434: #define T_PHREAL80 0x0342 /* huge pointer to 80 bit real */
435: #define T_32PREAL80 0x0442 /* 16:32 near pointer to 80 bit real */
436: #define T_32PFREAL80 0x0542 /* 16:32 far pointer to 80 bit real */
437:
438: /*
439: * 128 bit real types
440: */
441:
442: #define T_REAL128 0x0043 /* 128 bit real */
443: #define T_PREAL128 0x0143 /* near pointer to 128 bit real */
444: #define T_PFREAL128 0x0243 /* far pointer to 128 bit real */
445: #define T_PHREAL128 0x0343 /* huge pointer to 128 bit real */
446: #define T_32PREAL128 0x0443 /* 16:32 near pointer to 128 bit real */
447: #define T_32PFREAL128 0x0543 /* 16:32 far pointer to 128 bit real */
448:
449: /*
450: * 32 bit complex types
451: */
452:
453: #define T_CPLX32 0x0050 /* 32 bit complex */
454: #define T_PCPLX32 0x0150 /* near pointer to 32 bit complex */
455: #define T_PFCPLX32 0x0250 /* far pointer to 32 bit complex */
456: #define T_PHCPLX32 0x0350 /* huge pointer to 32 bit complex */
457: #define T_32PCPLX32 0x0450 /* 16:32 near pointer to 32 bit complex */
458: #define T_32PFCPLX32 0x0550 /* 16:32 far pointer to 32 bit complex */
459:
460: /*
461: * 48 bit complex types
462: */
463:
464: #define T_CPLX48 0x0054 /* 48 bit complex */
465: #define T_PCPLX48 0x0154 /* near pointer to 48 bit complex */
466: #define T_PFCPLX48 0x0254 /* far pointer to 48 bit complex */
467: #define T_PHCPLX48 0x0354 /* huge pointer to 48 bit complex */
468: #define T_32PCPLX48 0x0454 /* 16:32 near pointer to 48 bit complex */
469: #define T_32PFCPLX48 0x0554 /* 16:32 far pointer to 48 bit complex */
470:
471: /*
472: * 64 bit complex types
473: */
474:
475: #define T_CPLX64 0x0051 /* 64 bit complex */
476: #define T_PCPLX64 0x0151 /* near pointer to 64 bit complex */
477: #define T_PFCPLX64 0x0251 /* far pointer to 64 bit complex */
478: #define T_PHCPLX64 0x0351 /* huge pointer to 64 bit complex */
479: #define T_32PCPLX64 0x0451 /* 16:32 near pointer to 64 bit complex */
480: #define T_32PFCPLX64 0x0551 /* 16:32 far pointer to 64 bit complex */
481:
482: /*
483: * 80 bit complex types
484: */
485:
486: #define T_CPLX80 0x0052 /* 80 bit complex */
487: #define T_PCPLX80 0x0152 /* near pointer to 80 bit complex */
488: #define T_PFCPLX80 0x0252 /* far pointer to 80 bit complex */
489: #define T_PHCPLX80 0x0352 /* huge pointer to 80 bit complex */
490: #define T_32PCPLX80 0x0452 /* 16:32 near pointer to 80 bit complex */
491: #define T_32PFCPLX80 0x0552 /* 16:32 far pointer to 80 bit complex */
492:
493: /*
494: * 128 bit complex types
495: */
496:
497: #define T_CPLX128 0x0053 /* 128 bit complex */
498: #define T_PCPLX128 0x0153 /* near pointer to 128 bit complex */
499: #define T_PFCPLX128 0x0253 /* far pointer to 128 bit complex */
500: #define T_PHCPLX128 0x0353 /* huge pointer to 128 bit real */
501: #define T_32PCPLX128 0x0453 /* 16:32 near pointer to 128 bit complex */
502: #define T_32PFCPLX128 0x0553 /* 16:32 far pointer to 128 bit complex */
503:
504: /*
505: * boolean types
506: */
507:
508: #define T_BOOL08 0x0030 /* 8 bit boolean */
509: #define T_BOOL16 0x0031 /* 16 bit boolean */
510: #define T_BOOL32 0x0032 /* 32 bit boolean */
511: #define T_PBOOL08 0x0130 /* near pointer to 8 bit boolean */
512: #define T_PBOOL16 0x0131 /* near pointer to 16 bit boolean */
513: #define T_PBOOL32 0x0132 /* near pointer to 32 bit boolean */
514: #define T_PFBOOL08 0x0230 /* far pointer to 8 bit boolean */
515: #define T_PFBOOL16 0x0231 /* far pointer to 16 bit boolean */
516: #define T_PFBOOL32 0x0232 /* far pointer to 32 bit boolean */
517: #define T_PHBOOL08 0x0330 /* huge pointer to 8 bit boolean */
518: #define T_PHBOOL16 0x0331 /* huge pointer to 16 bit boolean */
519: #define T_PHBOOL32 0x0332 /* huge pointer to 32 bit boolean */
520:
521: #define T_32PBOOL08 0x0430 /* 16:32 near pointer to 8 bit boolean */
522: #define T_32PFBOOL08 0x0530 /* 16:32 far pointer to 8 bit boolean */
523: #define T_32PBOOL16 0x0431 /* 16:32 near pointer to 18 bit boolean */
524: #define T_32PFBOOL16 0x0531 /* 16:32 far pointer to 16 bit boolean */
525: #define T_32PBOOL32 0x0432 /* 16:32 near pointer to 32 bit boolean */
526: #define T_32PFBOOL32 0x0532 /* 16:32 far pointer to 32 bit boolean */
527:
528:
529: #define T_NCVPTR 0x01f0 /* CV Internal type for created near pointers */
530: #define T_FCVPTR 0x02f0 /* CV Internal type for created far pointers */
531: #define T_HCVPTR 0x03f0 /* CV Internal type for created huge pointers */
532:
533: /** No leaf index can have a value of 0x0000. The leaf indices are
534: * separated into ranges depending upon the use of the type record.
535: * The second range is for the type records that are directly referenced
536: * in symbols. The first range is for type records that are not
537: * referenced by symbols but instead are referenced by other type
538: * records. All type records must have a starting leaf index in these
539: * first two ranges. The third range of leaf indices are used to build
540: * up complex lists such as the field list of a class type record. No
541: * type record can begin with one of the leaf indices. The fourth ranges
542: * of type indices are used to represent numeric data in a symbol or
543: * type record. These leaf indices are greater than 0x8000. At the
544: * point that type or symbol processor is expecting a numeric field, the
545: * next two bytes in the type record are examined. If the value is less
546: * than 0x8000, then the two bytes contain the numeric value. If the
547: * value is greater than 0x8000, then the data follows the leaf index in
548: * a format specified by the leaf index. The final range of leaf indices
549: * are used to force alignment of subfields within a complex type record..
550: */
551:
552: /*
553: * leaf indices starting records but referenced from symbol records
554: */
555:
556: #define LF_MODIFIER 0x0001
557: #define LF_POINTER 0x0002
558: #define LF_ARRAY 0x0003
559: #define LF_CLASS 0x0004
560: #define LF_STRUCTURE 0x0005
561: #define LF_UNION 0x0006
562: #define LF_ENUM 0x0007
563: #define LF_PROCEDURE 0x0008
564: #define LF_MFUNCTION 0x0009
565: #define LF_VTSHAPE 0x000a
566: #define LF_COBOL0 0x000b
567: #define LF_COBOL1 0x000c
568: #define LF_BARRAY 0x000d
569: #define LF_LABEL 0x000e
570: #define LF_NULL 0x000f
571: #define LF_NOTTRAN 0x0010
572: #define LF_DIMARRAY 0x0011
573: #define LF_VFTPATH 0x0012
574: #define LF_PRECOMP 0x0013 /* not refereced from symbol */
575: #define LF_ENDPRECOMP 0x0014 /* not refereced from symbol */
576: #define LF_OEM 0x0015
577: #define LF_TYPESERVER 0x0016
578:
579: /*
580: * leaf indices starting records but referenced only from type records
581: */
582:
583: #define LF_SKIP 0x0200
584: #define LF_ARGLIST 0x0201
585: #define LF_DEFARG 0x0202
586: #define LF_LIST 0x0203
587: #define LF_FIELDLIST 0x0204
588: #define LF_DERIVED 0x0205
589: #define LF_BITFIELD 0x0206
590: #define LF_METHODLIST 0x0207
591: #define LF_DIMCONU 0x0208
592: #define LF_DIMCONLU 0x0209
593: #define LF_DIMVARU 0x020a
594: #define LF_DIMVARLU 0x020b
595: #define LF_REFSYM 0x020c
596:
597: #define LF_BCLASS 0x0400
598: #define LF_VBCLASS 0x0401
599: #define LF_IVBCLASS 0x0402
600: #define LF_ENUMERATE 0x0403
601: #define LF_FRIENDFCN 0x0404
602: #define LF_INDEX 0x0405
603: #define LF_MEMBER 0x0406
604: #define LF_STMEMBER 0x0407
605: #define LF_METHOD 0x0408
606: #define LF_NESTTYPE 0x0409
607: #define LF_VFUNCTAB 0x040a
608: #define LF_FRIENDCLS 0x040b
609:
610: #define LF_NUMERIC 0x8000
611: #define LF_CHAR 0x8000
612: #define LF_SHORT 0x8001
613: #define LF_USHORT 0x8002
614: #define LF_LONG 0x8003
615: #define LF_ULONG 0x8004
616: #define LF_REAL32 0x8005
617: #define LF_REAL64 0x8006
618: #define LF_REAL80 0x8007
619: #define LF_REAL128 0x8008
620: #define LF_QUADWORD 0x8009
621: #define LF_UQUADWORD 0x800a
622: #define LF_REAL48 0x800b
623:
624: #define LF_PAD0 0xf0
625: #define LF_PAD1 0xf1
626: #define LF_PAD2 0xf2
627: #define LF_PAD3 0xf3
628: #define LF_PAD4 0xf4
629: #define LF_PAD5 0xf5
630: #define LF_PAD6 0xf6
631: #define LF_PAD7 0xf7
632: #define LF_PAD8 0xf8
633: #define LF_PAD9 0xf9
634: #define LF_PAD10 0xfa
635: #define LF_PAD11 0xfb
636: #define LF_PAD12 0xfc
637: #define LF_PAD13 0xfd
638: #define LF_PAD14 0xfe
639: #define LF_PAD15 0xff
640:
641: /*
642: * end of leaf indices
643: */
644:
645: /*
646: * Type enum for pointer records
647: * Pointers can be one of the following types
648: */
649:
650: typedef enum CV_ptrtype_e {
651: CV_PTR_NEAR = 0x00, /* near pointer */
652: CV_PTR_FAR = 0x01, /* far pointer */
653: CV_PTR_HUGE = 0x02, /* huge pointer */
654: CV_PTR_BASE_SEG = 0x03, /* based on segment */
655: CV_PTR_BASE_VAL = 0x04, /* based on value of base */
656: CV_PTR_BASE_SEGVAL = 0x05, /* based on segment value of base */
657: CV_PTR_BASE_ADDR = 0x06, /* based on address of base */
658: CV_PTR_BASE_SEGADDR = 0x07, /* based on segment address of base */
659: CV_PTR_BASE_TYPE = 0x08, /* based on type */
660: CV_PTR_BASE_SELF = 0x09, /* based on self */
661: CV_PTR_NEAR32 = 0x0a, /* 16:32 near pointer */
662: CV_PTR_FAR32 = 0x0b, /* 16:32 far pointer */
663: CV_PTR_UNUSEDPTR = 0x0c /* first unused pointer type */
664: } CV_ptrtype_e;
665:
666: /*
667: * Mode enum for pointers
668: * Pointers can have one of the following modes
669: */
670:
671: typedef enum CV_ptrmode_e {
672: CV_PTR_MODE_PTR = 0x00, /* "normal" pointer */
673: CV_PTR_MODE_REF = 0x01, /* reference */
674: CV_PTR_MODE_PMEM = 0x02, /* pointer to data member */
675: CV_PTR_MODE_PMFUNC = 0x03, /* pointer to member function */
676: CV_PTR_MODE_RESERVED= 0x04 /* first unused pointer mode */
677: } CV_ptrmode_e;
678:
679: /*
680: * Enumeration for function call type
681: */
682:
683: typedef enum CV_call_e {
684: CV_CALL_NEAR_C = 0x00, /* near right to left push, caller pops stack */
685: CV_CALL_FAR_C = 0x01, /* far right to left push, caller pops stack */
686: CV_CALL_NEAR_PASCAL = 0x02, /* near left to right push, callee pops stack */
687: CV_CALL_FAR_PASCAL = 0x03, /* far left to right push, callee pops stack */
688: CV_CALL_NEAR_FAST = 0x04, /* near left to right push with regs, callee pops stack */
689: CV_CALL_FAR_FAST = 0x05, /* far left to right push with regs, callee pops stack */
690: CV_CALL_PCODE = 0x06, /* pcode */
691: CV_CALL_NEAR_STD = 0x07, /* near standard call */
692: CV_CALL_FAR_STD = 0x08, /* far standard call */
693: CV_CALL_NEAR_SYS = 0x09, /* near sys call */
694: CV_CALL_FAR_SYS = 0x0a, /* far sys call */
695: CV_CALL_THISCALL = 0x0b, /* this call (this passed in register) */
696: CV_CALL_MIPSCALL = 0x0c, /* Mips call */
697: CV_CALL_GENERIC = 0x0d, // Generic call sequence
698: CV_CALL_ALPHACALL = 0x0e, // Alpha call
699: CV_CALL_RESERVED = 0x0f // first unused call enumeration
700:
701: } CV_call_e;
702:
703: /*
704: * Values for the access protection of class attributes
705: */
706:
707: typedef enum CV_access_e {
708: CV_private = 1,
709: CV_protected = 2,
710: CV_public = 3
711: } CV_access_e;
712:
713: /*
714: * enumeration for method properties
715: */
716:
717: typedef enum CV_methodprop_e {
718: CV_MTvanilla = 0x00,
719: CV_MTvirtual = 0x01,
720: CV_MTstatic = 0x02,
721: CV_MTfriend = 0x03,
722: CV_MTintro = 0x04,
723: CV_MTpurevirt = 0x05,
724: CV_MTpureintro = 0x06
725: } CV_methodprop_e;
726:
727: /*
728: * enumeration for virtual shape table entries
729: */
730:
731: typedef enum CV_VTS_desc_e {
732: CV_VTS_near = 0x00,
733: CV_VTS_far = 0x01,
734: CV_VTS_thin = 0x02,
735: CV_VTS_outer = 0x03,
736: CV_VTS_meta = 0x04,
737: CV_VTS_near32 = 0x05,
738: CV_VTS_far32 = 0x06,
739: CV_VTS_unused = 0x07
740: } CV_VTS_desc_e;
741:
742: /*
743: * enumeration for LF_LABEL address modes
744: */
745:
746: typedef enum CV_LABEL_TYPE_e {
747: CV_LABEL_NEAR = 0, /* near return */
748: CV_LABEL_FAR = 4 /* far return */
749: } CV_LABEL_TYPE_e;
750:
751: /*
752: * enumeration for LF_MODIFIER values
753: */
754:
755: typedef struct CV_modifier_t {
756: unsigned short MOD_const :1;
757: unsigned short MOD_volatile :1;
758: unsigned short MOD_unused :14;
759: } CV_modifier_t;
760:
761: /*
762: * bit field structure describing class/struct/union/enum properties
763: */
764:
765: typedef struct CV_prop_t {
766: unsigned short packed :1; /* structure is packed */
767: unsigned short ctor :1; /* constructors or destructors present */
768: unsigned short ovlops :1; /* overloaded operators present */
769: unsigned short isnested :1; /* this is a nested class */
770: unsigned short cnested :1; /* this class contains nested types */
771: unsigned short opassign :1; /* overloaded assignment (=) */
772: unsigned short opcast :1; /* casting methods */
773: unsigned short fwdref :1; /* forward reference (incomplete defn) */
774: unsigned short scoped :1; /* scoped definition */
775: unsigned short reserved :7;
776: } CV_prop_t;
777:
778: /*
779: * class field attribute
780: */
781:
782: typedef struct CV_fldattr_t {
783: unsigned short access :2; /* access protection CV_access_t */
784: unsigned short mprop :3; /* method properties CV_methodprop_t */
785: unsigned short pseudo :1; /* compiler generated fcn and does not exist */
786: unsigned short noinherit :1; /* true if class cannot be inherited */
787: unsigned short noconstruct :1; /* true if class cannot be constructed */
788: unsigned short unused :8; /* unused */
789: } CV_fldattr_t;
790:
791: /*
792: * Structures to access to the type records
793: */
794:
795: typedef struct TYPTYPE {
796: unsigned short len;
797: unsigned short leaf;
798: #ifdef CV
799: unsigned char data[];
800: #else
801: unsigned char data[1];
802: #endif
803: } TYPTYPE; /* general types record */
804:
805: typedef enum CV_PMEMBER {
806: CV_PDM16_NONVIRT = 0x00, /* 16:16 data no virtual fcn or base (null = -1) */
807: CV_PDM16_VFCN = 0x01, /* 16:16 data with virtual functions null = 0 */
808: CV_PDM16_VBASE = 0x02, /* 16:16 data with virtual bases null = (,,-1) */
809: CV_PDM32_NVVFCN = 0x03, /* 16:32 data w/wo virtual functions null = 0x80000000 */
810: CV_PDM32_VBASE = 0x04, /* 16:32 data with virtual bases (,,-1L) */
811:
812: CV_PMF16_NEARNVSA = 0x05, /* 16:16 near method nonvirtual single address point */
813: CV_PMF16_NEARNVMA = 0x06, /* 16:16 near method nonvirtual multiple address points */
814: CV_PMF16_NEARVBASE = 0x07, /* 16:16 near method virtual bases */
815: CV_PMF16_FARNVSA = 0x08, /* 16:16 far method nonvirtual single address point */
816: CV_PMF16_FARNVMA = 0x09, /* 16:16 far method nonvirtual multiple address points */
817: CV_PMF16_FARVBASE = 0x0a, /* 16:16 far method virtual bases */
818:
819: CV_PMF32_NVSA = 0x0b, /* 16:32 method nonvirtual single address point */
820: CV_PMF32_NVMA = 0x0c, /* 16:32 method nonvirtual multiple address point */
821: CV_PMF32_VBASE = 0x0d /* 16:32 method virtual bases */
822: } CV_PMEMBER;
823:
824:
825: /*
826: * memory representation of pointer to member. These representations are
827: * indexed by the enumeration above in the LF_POINTER record
828: */
829:
830: /* representation of a 16:16 pointer to data for a class with no
831: * virtual functions or virtual bases
832: */
833:
834: struct CV_PDMR16_NONVIRT {
835: CV_off16_t mdisp; /* displacement to data (NULL = -1) */
836: };
837:
838:
839: /*
840: * representation of a 16:16 pointer to data for a class with virtual
841: * functions
842: */
843:
844: struct CV_PMDR16_VFCN {
845: CV_off16_t mdisp; /* displacement to data ( NULL = 0) */
846: };
847:
848: /*
849: * representation of a 16:16 pointer to data for a class with
850: * virtual bases
851: */
852:
853: struct CV_PDMR16_VBASE {
854: CV_off16_t mdisp; /* displacement to data */
855: CV_off16_t pdisp; /* this pointer displacement to vbptr */
856: CV_off16_t vdisp; /* displacement within vbase table */
857: };
858:
859: /*
860: * representation of a 16:32 near pointer to data for a class with
861: * or without virtual functions and no virtual bases
862: */
863:
864: struct CV_PDMR32_NVVFCN {
865: CV_off32_t mdisp; /* displacement to data (NULL = 0x80000000) */
866: };
867:
868:
869: /*
870: * representation of a 16:32 near pointer to data for a class
871: * with virtual bases
872: */
873:
874:
875: struct CV_PDMR32_VBASE {
876: CV_off32_t mdisp; /* displacement to data */
877: CV_off32_t pdisp; /* this pointer displacement */
878: CV_off32_t vdisp; /* vbase table displacement */
879: };
880:
881: /*
882: * representation of a 16:16 pointer to near member function for a
883: * class with no virtual functions or bases and a single address point
884: */
885:
886: struct CV_PMFR16_NEARNVSA {
887: CV_uoff16_t off; /* near address of function (NULL = 0) */
888: };
889:
890:
891: /*
892: * representation of a 16:16 pointer to far member function for a
893: * class with no virtual bases and a single address point
894: */
895:
896: struct CV_PMFR16_FARNVSA {
897: CV_uoff16_t off; /* offset of function (NULL = 0:0) */
898: unsigned short seg; /* segment of function */
899: };
900:
901:
902:
903: /*
904: * representation of a 16:16 near pointer to member functions of an
905: * class with no virtual bases and multiple address points
906: */
907:
908: struct CV_PMFR16_NEARNVMA {
909: CV_uoff16_t off; /* offset of function (NULL = 0,x) */
910: signed short disp;
911: };
912:
913: /*
914: * representation of a 16:16 far pointer to member functions of a
915: * class with no virtual bases and multiple address points
916: */
917:
918: struct CV_PMFR16_FARNVMA {
919: CV_uoff16_t off; /* offset of function (NULL = 0:0,x) */
920: unsigned short seg;
921: signed short disp;
922: };
923:
924: /*
925: * representation of a 16:16 near pointer to member function of a
926: * class with virtual bases
927: */
928:
929: struct CV_PMFR16_NEARVBASE {
930: CV_uoff16_t off; /* offset of function (NULL = 0,x,x,x) */
931: CV_off16_t mdisp; /* displacement to data */
932: CV_off16_t pdisp; /* this pointer displacement */
933: CV_off16_t vdisp; /* vbase table displacement */
934: };
935:
936: /*
937: * representation of a 16:16 far pointer to member function of a
938: * class with virtual bases
939: */
940:
941: struct CV_PMFR16_FARVBASE {
942: CV_uoff16_t off; /* offset of function (NULL = 0:0,x,x,x) */
943: unsigned short seg;
944: CV_off16_t mdisp; /* displacement to data */
945: CV_off16_t pdisp; /* this pointer displacement */
946: CV_off16_t vdisp; /* vbase table displacement */
947:
948: };
949:
950: /*
951: * representation of a 16:32 near pointer to member function for a
952: * class with no virtual bases and a single address point
953: */
954:
955: struct CV_PMFR32_NVSA {
956: CV_uoff32_t off; /* near address of function (NULL = 0L) */
957: };
958:
959: /*
960: * representation of a 16:32 near pointer to member function for a
961: * class with no virtual bases and multiple address points
962: */
963:
964: struct CV_PMFR32_NVMA {
965: CV_uoff32_t off; /* near address of function (NULL = 0L,x) */
966: CV_off32_t disp;
967: };
968:
969: /*
970: * representation of a 16:32 near pointer to member function for a
971: * class with virtual bases
972: */
973:
974: struct CV_PMFR32_VBASE {
975: CV_uoff32_t off; /* near address of function (NULL = 0L,x,x,x) */
976: CV_off32_t mdisp; /* displacement to data */
977: CV_off32_t pdisp; /* this pointer displacement */
978: CV_off32_t vdisp; /* vbase table displacement */
979: };
980:
981: /*
982: * Easy leaf - used for generic casting to reference leaf field
983: * of a subfield of a complex list
984: */
985:
986: typedef struct lfEasy {
987: unsigned short leaf; /* LF_... */
988: } lfEasy;
989:
990:
991: /* The following type records are basically variant records of the
992: * above structure. The "unsigned short leaf" of the above structure and
993: * the "unsigned short leaf" of the following type definitions are the
994: * same symbol. When the OMF record is locked via the MHOMFLock API
995: * call, the address of the "unsigned short leaf" is returned
996: */
997:
998: /*
999: * Type record for LF_MODIFIER
1000: */
1001:
1002: typedef struct lfModifier {
1003: unsigned short leaf; /* LF_MODIFIER */
1004: CV_modifier_t attr; /* modifier attribute modifier_t */
1005: CV_typ_t type; /* modified type */
1006: } lfModifier;
1007:
1008: /*
1009: * type record for LF_POINTER
1010: */
1011:
1012: typedef struct lfPointer {
1013: struct lfPointerBody {
1014: unsigned short leaf; /* LF_POINTER */
1015: struct {
1016: unsigned char ptrtype :5; /* ordinal specifying pointer type (ptrtype-t) */
1017: unsigned char ptrmode :3; /* ordinal specifying pointer mode (ptrmode_t) */
1018: unsigned char isflat32 :1; /* true if 0:32 pointer */
1019: unsigned char isvolatile :1; /* TRUE if volatile pointer */
1020: unsigned char isconst :1; /* TRUE if const pointer */
1021: unsigned char unused :5;
1022: } attr;
1023: CV_typ_t utype; /* type index of the underlying type */
1024: } u;
1025: union {
1026: struct {
1027: CV_typ_t pmclass; /* index of containing class for pointer to member */
1028: unsigned short pmenum; /* enumeration specifying pm format */
1029: } pm;
1030: unsigned short bseg; /* base segment if PTR_BASE_SEG */
1031: unsigned char Sym[1]; /* copy of base symbol record (including length) */
1032: struct {
1033: unsigned short index; /* type index if CV_PTR_BASE_TYPE */
1034: unsigned char name[1]; /* name of base type */
1035: } btype;
1036: } pbase;
1037: } lfPointer;
1038:
1039: /*
1040: * type record for LF_ARRAY
1041: */
1042:
1043: typedef struct lfArray {
1044: unsigned short leaf; /* LF_ARRAY */
1045: CV_typ_t elemtype; /* type index of element type */
1046: CV_typ_t idxtype; /* type index of indexing type */
1047: unsigned char data[]; /* variable length data specifying */
1048: /* size in bytes and name */
1049: } lfArray;
1050:
1051: /*
1052: * type record for LF_CLASS, LF_STRUCTURE
1053: */
1054:
1055: typedef struct lfClass {
1056: unsigned short leaf; /* LF_CLASS, LF_STRUCT */
1057: unsigned short count; /* count of number of elements in class */
1058: CV_typ_t field; /* type index of LF_FIELD descriptor list */
1059: CV_prop_t property; /* property attribute field (prop_t) */
1060: CV_typ_t derived; /* type index of derived from list if not zero */
1061: CV_typ_t vshape; /* type index of vshape table for this class */
1062: unsigned char data[]; /* data describing length of structure in */
1063: /* bytes and name */
1064: } lfClass;
1065: typedef lfClass lfStructure;
1066:
1067: /*
1068: * type record for LF_UNION
1069: */
1070:
1071: typedef struct lfUnion {
1072: unsigned short leaf; /* LF_UNION */
1073: unsigned short count; /* count of number of elements in class */
1074: CV_typ_t field; /* type index of LF_FIELD descriptor list */
1075: CV_prop_t property; /* property attribute field */
1076: unsigned char data[]; /* variable length data describing length of */
1077: /* structure and name */
1078: } lfUnion;
1079:
1080: /*
1081: * type record for LF_ENUM
1082: */
1083:
1084: typedef struct lfEnum {
1085: unsigned short leaf; /* LF_ENUM */
1086: unsigned short count; /* count of number of elements in class */
1087: CV_typ_t utype; /* underlying type of the enum */
1088: CV_typ_t field; /* type index of LF_FIELD descriptor list */
1089: CV_prop_t property; /* property attribute field */
1090: unsigned char Name[1]; /* length prefixed name of enum */
1091: } lfEnum;
1092:
1093: /*
1094: * Type record for LF_PROCEDURE
1095: */
1096:
1097: typedef struct lfProc {
1098: unsigned short leaf; /* LF_PROCEDURE */
1099: CV_typ_t rvtype; /* type index of return value */
1100: unsigned char calltype; /* calling convention (call_t) */
1101: unsigned char reserved; /* reserved for future use */
1102: unsigned short parmcount; /* number of parameters */
1103: CV_typ_t arglist; /* type index of argument list */
1104: } lfProc;
1105:
1106: /*
1107: * Type record for member function
1108: */
1109:
1110: typedef struct lfMFunc {
1111: unsigned short leaf; /* LF_MFUNCTION */
1112: CV_typ_t rvtype; /* type index of return value */
1113: CV_typ_t classtype; /* type index of containing class */
1114: CV_typ_t thistype; /* type index of this pointer (model specific) */
1115: unsigned char calltype; /* calling convention (call_t) */
1116: unsigned char reserved; /* reserved for future use */
1117: unsigned short parmcount; /* number of parameters */
1118: CV_typ_t arglist; /* type index of argument list */
1119: long thisadjust; /* this adjuster (long because pad required anyway) */
1120: } lfMFunc;
1121:
1122: /*
1123: * type record for virtual function table shape
1124: */
1125:
1126: typedef struct lfVTShape {
1127: unsigned short leaf; /* LF_VTSHAPE */
1128: unsigned short count; /* number of entries in vfunctable */
1129: unsigned char desc[]; /* variable number of 4 bit (VTS_desc) descriptors */
1130: } lfVTShape;
1131:
1132: /*
1133: * type record for cobol0
1134: */
1135:
1136: typedef struct lfCobol0 {
1137: unsigned short leaf; /* LF_COBOL0 */
1138: CV_typ_t type;
1139: unsigned char data[];
1140: } lfCobol0;
1141:
1142: /*
1143: * type record for cobol1
1144: */
1145:
1146: typedef struct lfCobol1 {
1147: unsigned short leaf; /* LF_COBOL1 */
1148: unsigned char data[];
1149: } lfCobol1;
1150:
1151: /*
1152: * type record for basic array
1153: */
1154:
1155: typedef struct lfBArray {
1156: unsigned short leaf; /* LF_BARRAY */
1157: CV_typ_t utype; /* type index of underlying type */
1158: } lfBArray;
1159:
1160: /*
1161: * type record for assembler labels
1162: */
1163:
1164: typedef struct lfLabel {
1165: unsigned short leaf; /* LF_LABEL */
1166: unsigned short mode; /* addressing mode of label */
1167: } lfLabel;
1168:
1169: /*
1170: * type record for dimensioned arrays
1171: */
1172:
1173: typedef struct lfDimArray {
1174: unsigned short leaf; /* LF_DIMARRAY */
1175: CV_typ_t utype; /* underlying type of the array */
1176: CV_typ_t diminfo; /* dimension information */
1177: char name[1]; /* length prefixed name */
1178: } lfDimArray;
1179:
1180: /*
1181: * type record describing path to virtual function table
1182: */
1183:
1184:
1185: typedef struct lfVFTPath {
1186: unsigned short leaf; /* LF_VFTPATH */
1187: unsigned short count; /* count of number of bases in path */
1188: CV_typ_t base[1]; /* bases from root to leaf */
1189: } lfVFTPath;
1190:
1191: /*
1192: * type record describing inclusion of precompiled types
1193: */
1194:
1195: typedef struct lfPreComp {
1196: unsigned short leaf; /* LF_PRECOMP */
1197: unsigned short start; /* starting type index included */
1198: unsigned short count; /* number of types in inclusion */
1199: unsigned long signature; /* signature */
1200: unsigned char name[]; /* length prefixed name of included type file */
1201: } lfPreComp;
1202:
1203: /*
1204: * type record describing end of precompiled types that will be
1205: * included by another file
1206: */
1207:
1208: typedef struct lfEndPreComp {
1209: unsigned short leaf; /* LF_ENDPRECOMP */
1210: unsigned long signature; /* signature */
1211: } lfEndPreComp;
1212:
1213: /*
1214: * description of type records that can be referenced from
1215: * type records referenced by symbols
1216: */
1217:
1218: /*
1219: * type record for skip record
1220: */
1221:
1222: typedef struct lfSkip {
1223: unsigned short leaf; /* LF_SKIP */
1224: CV_typ_t type; /* next valid index */
1225: unsigned char data[]; /* pad data */
1226: } lfSkip;
1227:
1228: /*
1229: * argument list leaf
1230: */
1231:
1232: typedef struct lfArgList {
1233: unsigned short leaf; /* LF_ARGLIST */
1234: unsigned short count; /* number of arguments */
1235: CV_typ_t arg[]; /* number of arguments */
1236: } lfArgList;
1237:
1238: /*
1239: * derived class list leaf
1240: */
1241:
1242: typedef struct lfDerived {
1243: unsigned short leaf; /* LF_DERIVED */
1244: unsigned short count; /* number of arguments */
1245: CV_typ_t drvdcls[]; /* type indices of derived classes */
1246: } lfDerived;
1247:
1248: /*
1249: * leaf for default arguments
1250: */
1251:
1252: typedef struct lfDefArg {
1253: unsigned short leaf; /* LF_DEFARG */
1254: CV_typ_t type; /* type of resulting expression */
1255: unsigned char expr[]; /* length prefixed expression string */
1256: } lfDefArg;
1257:
1258: /*
1259: * list leaf
1260: * This list should no longer be used because the utilities cannot
1261: * verify the contents of the list without knowing what type of list
1262: * it is. New specific leaf indices should be used instead.
1263: */
1264:
1265: typedef struct lfList {
1266: unsigned short leaf; /* LF_LIST */
1267: char data[]; /* data format specified by indexing type */
1268: } lfList;
1269:
1270: /*
1271: * field list leaf
1272: * This is the header leaf for a complex list of class and structure
1273: * subfields.
1274: */
1275:
1276: typedef struct lfFieldList {
1277: unsigned short leaf; /* LF_FIELDLIST */
1278: char data[]; /* field list sub lists */
1279: } lfFieldList;
1280:
1281: /*
1282: * type record for non-static methods and friends in method list
1283: */
1284:
1285: typedef struct mlMethod {
1286: CV_fldattr_t attr; /* method attribute */
1287: CV_typ_t index; /* index to type record for procedure */
1288: #ifdef CV
1289: unsigned long vbaseoff[0]; /* offset in vfunctable if intro virtual */
1290: #else
1291: // unsigned long vbaseoff[1];
1292: #endif
1293: } mlMethod;
1294:
1295: typedef struct lfMethodList {
1296: unsigned short leaf;
1297: unsigned char mList[]; /* really a mlMethod type */
1298: } lfMethodList;
1299:
1300: /*
1301: * type record for LF_BITFIELD
1302: */
1303:
1304: typedef struct lfBitfield {
1305: unsigned short leaf; /* LF_BITFIELD */
1306: unsigned char length;
1307: unsigned char position;
1308: CV_typ_t type; /* type of bitfield */
1309:
1310: } lfBitfield;
1311:
1312: /*
1313: * type record for dimensioned array with constant bounds
1314: */
1315:
1316: typedef struct lfDimCon {
1317: unsigned short leaf; /* LF_DIMCONU or LF_DIMCONLU */
1318: unsigned short rank; /* number of dimensions */
1319: CV_typ_t typ; /* type of index */
1320: unsigned char dim[]; /* array of dimension information with */
1321: /* either upper bounds or lower/upper bound */
1322: } lfDimCon;
1323:
1324: /*
1325: * type record for dimensioned array with variable bounds
1326: */
1327:
1328: typedef struct lfDimVar {
1329: unsigned short leaf; /* LF_DIMVARU or LF_DIMVARLU */
1330: unsigned short rank; /* number of dimensions */
1331: CV_typ_t typ; /* type of index */
1332: unsigned char dim[]; /* array of type indices for either */
1333: /* variable upper bound or variable */
1334: /* lower/upper bound. The referenced */
1335: /* types must be LF_REFSYM or T_VOID */
1336: } lfDimVar;
1337:
1338: /*
1339: * type record for referenced symbol
1340: */
1341:
1342: typedef struct lfRefSym {
1343: unsigned short leaf; /* LF_REFSYM */
1344: unsigned char Sym[1]; /* copy of referenced symbol record */
1345: /* (including length) */
1346: } lfRefSym;
1347:
1348: /** the following are numeric leaves. They are used to indicate the
1349: * size of the following variable length data. When the numeric
1350: * data is a single byte less than 0x8000, then the data is output
1351: * directly. If the data is more the 0x8000 or is a negative value,
1352: * then the data is preceeded by the proper index.
1353: */
1354:
1355: /* signed character leaf */
1356:
1357: typedef struct lfChar {
1358: unsigned short leaf; /* LF_CHAR */
1359: signed char val; /* signed 8-bit value */
1360: } lfChar;
1361:
1362: /* signed short leaf */
1363:
1364: typedef struct lfShort {
1365: unsigned short leaf; /* LF_SHORT */
1366: short val; /* signed 16-bit value */
1367: } lfShort;
1368:
1369: /* unsigned short leaf */
1370:
1371: typedef struct lfUShort {
1372: unsigned short leaf; /* LF_unsigned short */
1373: unsigned short val; /* unsigned 16-bit value */
1374: } lfUShort;
1375:
1376: /* signed long leaf */
1377:
1378: typedef struct lfLong {
1379: unsigned short leaf; /* LF_LONG */
1380: long val; /* signed 32-bit value */
1381: } lfLong;
1382:
1383: /* unsigned long leaf */
1384:
1385: typedef struct lfULong {
1386: unsigned short leaf; /* LF_ULONG */
1387: unsigned long val; /* unsigned 32-bit value */
1388: } lfULong;
1389:
1390: /* real 32-bit leaf */
1391:
1392: typedef struct lfReal32 {
1393: unsigned short leaf; /* LF_REAL32 */
1394: float val; /* 32-bit real value */
1395: } lfReal32;
1396:
1397: /* real 48-bit leaf */
1398:
1399: typedef struct lfReal48 {
1400: unsigned short leaf; /* LF_REAL48 */
1401: unsigned char val[6]; /* 48-bit real value */
1402: } lfReal48;
1403:
1404: /* real 64-bit leaf */
1405:
1406: typedef struct lfReal64 {
1407: unsigned short leaf; /* LF_REAL64 */
1408: double val; /* 64-bit real value */
1409: } lfReal64;
1410:
1411: /* real 80-bit leaf */
1412:
1413: typedef struct lfReal80 {
1414: unsigned short leaf; /* LF_REAL80 */
1415: REAL10 val; /* real 80-bit value */
1416: } lfReal80;
1417:
1418: /* real 128-bit leaf */
1419:
1420: typedef struct lfReal128 {
1421: unsigned short leaf; /* LF_REAL128 */
1422: char val[16]; /* real 128-bit value */
1423: } lfReal128;
1424:
1425: /************************************************************************/
1426:
1427: /* index leaf - contains type index of another leaf */
1428: /* a major use of this leaf is to allow the compilers to emit a */
1429: /* long complex list (LF_FIELD) in smaller pieces. */
1430:
1431: typedef struct lfIndex {
1432: unsigned short leaf; /* LF_INDEX */
1433: CV_typ_t index; /* type index of referenced leaf */
1434: } lfIndex;
1435:
1436: /* subfield record for base class field */
1437:
1438: typedef struct lfBClass {
1439: unsigned short leaf; /* LF_BCLASS */
1440: CV_typ_t index; /* type index of base class */
1441: CV_fldattr_t attr; /* attribute */
1442: unsigned char offset[]; /* variable length offset of base within class */
1443: } lfBClass;
1444:
1445: /* subfield record for direct and indirect virtual base class field */
1446:
1447: typedef struct lfVBClass {
1448: unsigned short leaf; /* LF_VBCLASS | LV_IVBCLASS */
1449: CV_typ_t index; /* type index of direct virtual base class */
1450: CV_typ_t vbptr; /* type index of virtual base pointer */
1451: CV_fldattr_t attr; /* attribute */
1452: unsigned char vbpoff[]; /* virtual base pointer offset from address point */
1453: /* followed by virtual base offset from vbtable */
1454: } lfVBClass;
1455:
1456: /* subfield record for friend class */
1457:
1458: typedef struct lfFriendCls {
1459: unsigned short leaf; /* LF_FRIENDCLS */
1460: CV_typ_t index; /* index to type record of friend class */
1461: } lfFriendCls;
1462:
1463: /* subfield record for friend function */
1464:
1465: typedef struct lfFriendFcn {
1466: unsigned short leaf; /* LF_FRIENDFCN */
1467: CV_typ_t index; /* index to type record of friend function */
1468: char Name[1]; /* name of friend function */
1469: } lfFriendFcn;
1470:
1471: /* subfield record for non-static data members */
1472:
1473: typedef struct lfMember {
1474: unsigned short leaf; /* LF_MEMBER */
1475: CV_typ_t index; /* index of type record for field */
1476: CV_fldattr_t attr; /* attribute mask */
1477: unsigned char offset[]; /* variable length offset of field followed */
1478: /* by length prefixed name of field */
1479: } lfMember;
1480:
1481: /* type record for static data members */
1482:
1483: typedef struct lfSTMember {
1484: unsigned short leaf; /* LF_STMEMBER */
1485: CV_typ_t index; /* index of type record for field */
1486: CV_fldattr_t attr; /* attribute mask */
1487: char Name[1]; /* length prefixed name of field */
1488: } lfSTMember;
1489:
1490: /* subfield record for virtual function table pointer */
1491:
1492: typedef struct lfVFuncTab {
1493: unsigned short leaf; /* LF_VFUNCTAB */
1494: CV_typ_t type; /* type index of pointer */
1495: } lfVFuncTab;
1496:
1497: /* subfield record for method and friend list */
1498:
1499: typedef struct lfMethod {
1500: unsigned short leaf; /* LF_METHOD */
1501: unsigned short count; /* number of occurances of function */
1502: CV_typ_t mList; /* index to LF_METHODLIST record */
1503: char Name[1]; /* length prefixed name of method */
1504: } lfMethod;
1505:
1506: /* subfield record for enumerate */
1507:
1508: typedef struct lfEnumerate {
1509: unsigned short leaf; /* LF_ENUMERATE */
1510: CV_fldattr_t attr; /* access (ACC_...) */
1511: unsigned char value[]; /* variable length value field followed */
1512: /* by length prefixed name */
1513: } lfEnumerate;
1514:
1515: /* type record for nested (scoped) type definition */
1516:
1517: typedef struct lfNestType {
1518: unsigned short leaf; /* LF_NESTTYPE */
1519: CV_typ_t index; /* index of nested type definition */
1520: unsigned char Name[1]; /* length prefixed type name */
1521: } lfNestType;
1522:
1523: /* type record for pad leaf */
1524:
1525: typedef struct lfPad {
1526: unsigned char leaf;
1527: } SYM_PAD;
1528:
1529: /* Symbol definitions */
1530:
1531: typedef enum SYM_ENUM_e {
1532: S_COMPILE = 0x0001, /* Compile flags symbol */
1533: S_REGISTER = 0x0002, /* Register variable */
1534: S_CONSTANT = 0x0003, /* constant symbol */
1535: S_UDT = 0x0004, /* User defined type */
1536: S_SSEARCH = 0x0005, /* Start Search */
1537: S_END = 0x0006, /* Block, procedure, "with" or thunk end */
1538: S_SKIP = 0x0007, /* Reserve symbol space in $$Symbols table */
1539: S_CVRESERVE = 0x0008, /* Reserve symbol for CV internal use */
1540: S_OBJNAME = 0x0009, /* path to object file name */
1541: S_ENDARG = 0x000a, /* end of argument list */
1542: S_COBOLUDT = 0x000b, /* special UDT for cobol -- not packed */
1543:
1544: S_BPREL16 = 0x0100, /* BP-relative */
1545: S_LDATA16 = 0x0101, /* Module-local symbol */
1546: S_GDATA16 = 0x0102, /* Global data symbol */
1547: S_PUB16 = 0x0103, /* a public symbol */
1548: S_LPROC16 = 0x0104, /* Local procedure start */
1549: S_GPROC16 = 0x0105, /* Global procedure start */
1550: S_THUNK16 = 0x0106, /* Thunk Start */
1551: S_BLOCK16 = 0x0107, /* block start */
1552: S_WITH16 = 0x0108, /* with start */
1553: S_LABEL16 = 0x0109, /* code label */
1554: S_CEXMODEL16 = 0x010a, /* change execution model */
1555: S_VFTABLE16 = 0x010b, /* address of virtual function table */
1556: S_REGREL16 = 0x010c, /* register relative address */
1557:
1558: S_BPREL32 = 0x0200, /* BP-relative */
1559: S_LDATA32 = 0x0201, /* Module-local symbol */
1560: S_GDATA32 = 0x0202, /* Global data symbol */
1561: S_PUB32 = 0x0203, /* a public symbol (CV internal reserved) */
1562: S_LPROC32 = 0x0204, /* Local procedure start */
1563: S_GPROC32 = 0x0205, /* Global procedure start */
1564: S_THUNK32 = 0x0206, /* Thunk Start */
1565: S_BLOCK32 = 0x0207, /* block start */
1566: S_WITH32 = 0x0208, /* with start */
1567: S_LABEL32 = 0x0209, /* code label */
1568: S_CEXMODEL32 = 0x020a, /* change execution model */
1569: S_VFTABLE32 = 0x020b, /* address of virtual function table */
1570: S_REGREL32 = 0x020c, /* register relative address */
1571: S_LTHREAD32 = 0x020d,
1572: S_GTHREAD32 = 0x020e,
1573:
1574: S_LPROCMIPS = 0x0300, /* Local procedure start */
1575: S_GPROCMIPS = 0x0301, /* Global procedure start */
1576:
1577: S_PROCREF = 0x400, /* Procedure reference */
1578: S_DATAREF = 0x401, /* Data reference */
1579: S_ALIGN = 0x402 /* Page Alignment */
1580: } SYM_ENUM_e;
1581:
1582: /* enum describing the compile flag source language */
1583:
1584: typedef enum {
1585: CV_CFL_C = 0x00,
1586: CV_CFL_CXX = 0x01,
1587: CV_CFL_FORTRAN = 0x02,
1588: CV_CFL_MASM = 0x03,
1589: CV_CFL_PASCAL = 0x04,
1590: CV_CFL_BASIC = 0x05,
1591: CV_CFL_COBOL = 0x06
1592: } CV_CFL_LANG;
1593:
1594: /* enum describing target processor */
1595:
1596: typedef enum CV_CPU_TYPE_e {
1597: CV_CFL_8080 = 0x00,
1598: CV_CFL_8086 = 0x01,
1599: CV_CFL_80286 = 0x02,
1600: CV_CFL_80386 = 0x03,
1601: CV_CFL_80486 = 0x04,
1602: CV_CFL_PENTIUM = 0x05,
1603: CV_CFL_MIPSR4000 = 0x10,
1604: CV_CFL_M68000 = 0x20,
1605: CV_CFL_M68010 = 0x21,
1606: CV_CFL_M68020 = 0x22,
1607: CV_CFL_M68030 = 0x23,
1608: CV_CFL_M68040 = 0x24,
1609: CV_CFL_ALPHA = 0x30
1610:
1611: } CV_CPU_TYPE_e;
1612:
1613: /* enum describing compile flag ambiant data model */
1614:
1615: typedef enum {
1616: CV_CFL_DNEAR = 0x00,
1617: CV_CFL_DFAR = 0x01,
1618: CV_CFL_DHUGE = 0x02
1619: } CV_CFL_DATA;
1620:
1621: /* enum describing compile flag ambiant code model */
1622:
1623: typedef enum CV_CFL_CODE_e {
1624: CV_CFL_CNEAR = 0x00,
1625: CV_CFL_CFAR = 0x01,
1626: CV_CFL_CHUGE = 0x02
1627: } CV_CFL_CODE_e;
1628:
1629: /* enum describing compile flag target floating point package */
1630:
1631: typedef enum CV_CFL_FPKG_e {
1632: CV_CFL_NDP = 0x00,
1633: CV_CFL_EMU = 0x01,
1634: CV_CFL_ALT = 0x02
1635: } CV_CFL_FPKG_e;
1636:
1637: typedef struct SYMTYPE {
1638: unsigned short reclen; /* Record length */
1639: unsigned short rectyp; /* Record type */
1640: char data[];
1641: } SYMTYPE;
1642:
1643: /*
1644: * cobol information ---
1645: */
1646:
1647: typedef enum CV_COBOL_e {
1648: CV_COBOL_dontstop,
1649: CV_COBOL_pfm,
1650: CV_COBOL_false,
1651: CV_COBOL_extcall
1652: } CV_COBOL_e;
1653:
1654: struct {
1655: unsigned short subtype; /* see CV_COBOL_e above */
1656: unsigned short flag;
1657: } cobol;
1658:
1659:
1660: /* non-model specific symbol types */
1661:
1662: typedef struct REGSYM {
1663: unsigned short reclen; /* Record length */
1664: unsigned short rectyp; /* S_REGISTER */
1665: unsigned short typind; /* Type index */
1666: unsigned short reg; /* register enumerate */
1667: unsigned char name[1]; /* Length-prefixed name */
1668: } REGSYM;
1669:
1670: typedef struct CONSTSYM {
1671: unsigned short reclen; /* Record length */
1672: unsigned short rectyp; /* S_CONSTANT */
1673: CV_typ_t typind; /* Type index (containing enum if enumerate) */
1674: unsigned short value; /* numeric leaf containing value */
1675: unsigned char name[]; /* Length-prefixed name */
1676: } CONSTSYM;
1677:
1678: typedef struct UDTSYM {
1679: unsigned short reclen; /* Record length */
1680: unsigned short rectyp; /* S_UDT |S_COBOLUDT */
1681: CV_typ_t typind; /* Type index */
1682: unsigned char name[1]; /* Length-prefixed name */
1683: } UDTSYM;
1684:
1685: typedef struct SEARCHSYM {
1686: unsigned short reclen; /* Record length */
1687: unsigned short rectyp; /* S_SSEARCH */
1688: unsigned long startsym; /* offset of the procedure */
1689: unsigned short seg; /* segment of symbol */
1690: } SEARCHSYM;
1691:
1692: typedef struct CFLAGSYM {
1693: unsigned short reclen; /* Record length */
1694: unsigned short rectyp; /* S_COMPILE */
1695: unsigned char machine; /* target processor */
1696: struct {
1697: unsigned char language :8; /* language index */
1698: unsigned char pcode :1; /* true if pcode present */
1699: unsigned char floatprec :2; /* floating precision */
1700: unsigned char floatpkg :2; /* float package */
1701: unsigned char ambdata :3; /* ambiant data model */
1702: unsigned char ambcode :3; /* ambiant code model */
1703: unsigned char mode32 :1; /* true if compiled 32 bit mode */
1704: unsigned char pad :4; /* reserved */
1705: } flags;
1706: unsigned char ver[1]; /* Length-prefixed compiler version string */
1707: } CFLAGSYM;
1708:
1709: typedef struct OBJNAMESYM {
1710: unsigned short reclen; /* Record length */
1711: unsigned short rectyp; /* S_OBJNAME */
1712: unsigned long signature; /* signature */
1713: unsigned char name[1]; /* Length-prefixed name */
1714: } OBJNAMESYM;
1715:
1716: /* symbol types for 16:16 memory model */
1717:
1718: typedef struct BPRELSYM16 {
1719: unsigned short reclen; /* Record length */
1720: unsigned short rectyp; /* S_BPREL16 */
1721: CV_off16_t off; /* BP-relative offset */
1722: CV_typ_t typind; /* Type index */
1723: unsigned char name[1]; /* Length-prefixed name */
1724: } BPRELSYM16;
1725:
1726: typedef struct DATASYM16 {
1727: unsigned short reclen; /* Record length */
1728: unsigned short rectyp; /* S_LDATA16 or S_GDATA16 or S_PUB16 */
1729: CV_uoff16_t off; /* offset of symbol */
1730: unsigned short seg; /* segment of symbol */
1731: CV_typ_t typind; /* Type index */
1732: unsigned char name[1]; /* Length-prefixed name */
1733: } DATASYM16;
1734: typedef DATASYM16 PUBSYM16;
1735:
1736: typedef struct PROCSYM16 {
1737: unsigned short reclen; /* Record length */
1738: unsigned short rectyp; /* S_GPROC16 or S_LPROC16 */
1739: unsigned long pParent; /* pointer to the parent */
1740: unsigned long pEnd; /* pointer to this blocks end */
1741: unsigned long pNext; /* pointer to next symbol */
1742: unsigned short len; /* Proc length */
1743: unsigned short DbgStart; /* Debug start offset */
1744: unsigned short DbgEnd; /* Debug end offset */
1745: CV_uoff16_t off; /* offset of symbol */
1746: unsigned short seg; /* segment of symbol */
1747: CV_typ_t typind; /* Type index */
1748: char rtntyp; /* Return type (NEAR/FAR) */
1749: unsigned char name[1]; /* Length-prefixed name */
1750: } PROCSYM16;
1751:
1752: typedef struct THUNKSYM16 {
1753: unsigned short reclen; /* Record length */
1754: unsigned short rectyp; /* S_THUNK16 */
1755: unsigned long pParent; /* pointer to the parent */
1756: unsigned long pEnd; /* pointer to this blocks end */
1757: unsigned long pNext; /* pointer to next symbol */
1758: CV_uoff16_t off; /* offset of symbol */
1759: unsigned short seg; /* segment of symbol */
1760: unsigned short len; /* length of thunk */
1761: unsigned char ord; /* ordinal specifying type of thunk */
1762: unsigned char name[1]; /* name of thunk */
1763: #ifdef CV
1764: unsigned char variant[0]; /* variant portion of thunk */
1765: #else
1766: unsigned char variant[1]; /* variant portion of thunk */
1767: #endif
1768: } THUNKSYM16;
1769:
1770: typedef enum {
1771: THUNK_ORDINAL_NOTYPE,
1772: THUNK_ORDINAL_ADJUSTOR,
1773: THUNK_ORDINAL_VCALL
1774: } THUNK_ORDINAL;
1775:
1776: typedef struct LABELSYM16 {
1777: unsigned short reclen; /* Record length */
1778: unsigned short rectyp; /* S_LABEL16 */
1779: CV_uoff16_t off; /* offset of symbol */
1780: unsigned short seg; /* segment of symbol */
1781: char rtntyp; /* Return type (NEAR/FAR) */
1782: unsigned char name[1]; /* Length-prefixed name */
1783: } LABELSYM16;
1784:
1785: typedef enum CV_RETURN_TYPE_e {
1786: CV_RETURN_NEAR = 0, /* near return */
1787: CV_RETURN_FAR = 4 /* far return */
1788: } CV_RETURN_TYPE_e;
1789:
1790: typedef struct BLOCKSYM16 {
1791: unsigned short reclen; /* Record length */
1792: unsigned short rectyp; /* S_BLOCK16 */
1793: unsigned long pParent; /* pointer to the parent */
1794: unsigned long pEnd; /* pointer to this blocks end */
1795: unsigned short len; /* Block length */
1796: CV_uoff16_t off; /* offset of symbol */
1797: unsigned short seg; /* segment of symbol */
1798: unsigned char name[1]; /* Length-prefixed name */
1799: } BLOCKSYM16;
1800:
1801: typedef struct WITHSYM16 {
1802: unsigned short reclen; /* Record length */
1803: unsigned short rectyp; /* S_WITH16 */
1804: unsigned long pParent; /* pointer to the parent */
1805: unsigned long pEnd; /* pointer to this blocks end */
1806: unsigned short len; /* Block length */
1807: CV_uoff16_t off; /* offset of symbol */
1808: unsigned short seg; /* segment of symbol */
1809: unsigned char name[1]; /* Length-prefixed name */
1810: } WITHSYM16;
1811:
1812: typedef enum CEXM_MODEL_e {
1813: CEXM_MDL_table = 0x00, /* not executable */
1814: CEXM_MDL_native = 0x20, /* native */
1815: CEXM_MDL_cobol = 0x21, /* cobol */
1816: CEXM_MDL_pcode = 0x40 /* pcode */
1817: } CEXM_MODEL_e;
1818:
1819: typedef struct CEXMSYM16 {
1820: unsigned short reclen; /* Record length */
1821: unsigned short rectyp; /* S_CEXMODEL16 */
1822: CV_uoff16_t off; /* offset of symbol */
1823: unsigned short seg; /* segment of symbol */
1824: unsigned short model; /* execution model */
1825: union variant {
1826: struct {
1827: CV_uoff16_t pcdtable; /* offset to pcode function table */
1828: CV_uoff16_t pcdspi; /* offset to segment pcode information */
1829: } pcode;
1830: } u;
1831: } CEXMSYM16;
1832:
1833: typedef struct VPATHSYM16 {
1834: unsigned short reclen; /* record length */
1835: unsigned short rectyp; /* S_VFTPATH16 */
1836: CV_uoff16_t off; /* offset of virtual function table */
1837: unsigned short seg; /* segment of virtual function table */
1838: CV_typ_t root; /* type index of the root of path */
1839: CV_typ_t path; /* type index of the path record */
1840: } VPATHSYM16;
1841:
1842: typedef struct REGREL16 {
1843: unsigned short reclen; /* Record length */
1844: unsigned short rectyp; /* S_REGREL16 */
1845: CV_uoff16_t off; /* offset of symbol */
1846: unsigned short reg; /* register index */
1847: CV_typ_t typind; /* Type index */
1848: unsigned char name[1]; /* Length-prefixed name */
1849: } REGREL16;
1850:
1851: typedef struct BPRELSYM32 {
1852: unsigned short reclen; /* Record length */
1853: unsigned short rectyp; /* S_BPREL32 */
1854: CV_off32_t off; /* BP-relative offset */
1855: CV_typ_t typind; /* Type index */
1856: unsigned char name[1]; /* Length-prefixed name */
1857: } BPRELSYM32;
1858:
1859: typedef struct DATASYM32 {
1860: unsigned short reclen; /* Record length */
1861: unsigned short rectyp; /* S_LDATA32, S_GDATA32, S_LTHREAD32,
1862: S_GTHREAD32 or S_PUB32 */
1863: CV_uoff32_t off;
1864: unsigned short seg;
1865: CV_typ_t typind; /* Type index */
1866: unsigned char name[1]; /* Length-prefixed name */
1867: } DATASYM32;
1868: typedef DATASYM32 PUBSYM32;
1869:
1870: typedef struct PROCSYM32 {
1871: unsigned short reclen; /* Record length */
1872: unsigned short rectyp; /* S_GPROC32 or S_LPROC32 */
1873: unsigned long pParent; /* pointer to the parent */
1874: unsigned long pEnd; /* pointer to this blocks end */
1875: unsigned long pNext; /* pointer to next symbol */
1876: unsigned long len; /* Proc length */
1877: unsigned long DbgStart; /* Debug start offset */
1878: unsigned long DbgEnd; /* Debug end offset */
1879: CV_uoff32_t off;
1880: unsigned short seg;
1881: CV_typ_t typind; /* Type index */
1882: char rtntyp; /* Return type (NEAR/FAR) */
1883: unsigned char name[1]; /* Length-prefixed name */
1884: } PROCSYM32;
1885:
1886: typedef struct THUNKSYM32 {
1887: unsigned short reclen; /* Record length */
1888: unsigned short rectyp; /* S_THUNK32 */
1889: unsigned long pParent; /* pointer to the parent */
1890: unsigned long pEnd; /* pointer to this blocks end */
1891: unsigned long pNext; /* pointer to next symbol */
1892: CV_uoff32_t off;
1893: unsigned short seg;
1894: unsigned short len; /* length of thunk */
1895: unsigned char ord; /* ordinal specifying type of thunk */
1896: unsigned char name[1]; /* Length-prefixed name */
1897: #ifdef CV
1898: unsigned char variant[0]; /* variant portion of thunk */
1899: #else
1900: unsigned char variant[1]; /* variant portion of thunk */
1901: #endif
1902: } THUNKSYM32;
1903:
1904: typedef struct LABELSYM32 {
1905: unsigned short reclen; /* Record length */
1906: unsigned short rectyp; /* S_LABEL32 */
1907: CV_uoff32_t off;
1908: unsigned short seg;
1909: char rtntyp; /* Return type (NEAR/FAR) */
1910: unsigned char name[1]; /* Length-prefixed name */
1911: } LABELSYM32;
1912:
1913: typedef struct BLOCKSYM32 {
1914: unsigned short reclen; /* Record length */
1915: unsigned short rectyp; /* S_BLOCK32 */
1916: unsigned long pParent; /* pointer to the parent */
1917: unsigned long pEnd; /* pointer to this blocks end */
1918: unsigned long len; /* Block length */
1919: CV_uoff32_t off; /* Offset in code segment */
1920: unsigned short seg; /* segment of label */
1921: unsigned char name[1]; /* Length-prefixed name */
1922: } BLOCKSYM32;
1923:
1924: typedef struct WITHSYM32 {
1925: unsigned short reclen; /* Record length */
1926: unsigned short rectyp; /* S_WITH32 */
1927: unsigned long pParent; /* pointer to the parent */
1928: unsigned long pEnd; /* pointer to this blocks end */
1929: unsigned long len; /* Block length */
1930: CV_uoff32_t off; /* Offset in code segment */
1931: unsigned short seg; /* segment of label */
1932: unsigned char name[1]; /* Length-prefixed expression string */
1933: } WITHSYM32;
1934:
1935: typedef struct VPATHSYM32 {
1936: unsigned short reclen; /* record length */
1937: unsigned short rectyp; /* S_VFTPATH32 */
1938: CV_uoff32_t off; /* offset of virtual function table */
1939: unsigned short seg; /* segment of virtual function table */
1940: CV_typ_t root; /* type index of the root of path */
1941: CV_typ_t path; /* type index of the path record */
1942: } VPATHSYM32;
1943:
1944: typedef struct REGREL32 {
1945: unsigned short reclen; /* Record length */
1946: unsigned short rectyp; /* S_REGREL32 */
1947: CV_uoff32_t off; /* offset of symbol */
1948: unsigned short reg; /* register index for symbol */
1949: CV_typ_t typind; /* Type index */
1950: unsigned char name[1]; /* Length-prefixed name */
1951: } REGREL32, * LPREGREL32;
1952:
1953: typedef struct PROCSYMMIPS {
1954: unsigned short reclen; /* Record length */
1955: unsigned short rectyp; /* S_GPROCMIPS or S_LPROCMIPS */
1956: unsigned long pParent; /* pointer to the parent */
1957: unsigned long pEnd; /* pointer to this blocks end */
1958: unsigned long pNext; /* pointer to next symbol */
1959: unsigned long len; /* Proc length */
1960: unsigned long DbgStart; /* Debug start offset */
1961: unsigned long DbgEnd; /* Debug end offset */
1962: unsigned long regSave; /* int register save mask */
1963: unsigned long fpSave; /* fp register save mask */
1964: unsigned long intOff; /* int register save offset */
1965: unsigned long fpOff; /* fp register save offset */
1966: CV_uoff32_t off; /* Symbol offset */
1967: unsigned short seg; /* Symbol segment */
1968: CV_typ_t typind; /* Type index */
1969: char retReg; /* Register return value is in */
1970: char frameReg; /* Frame pointer register */
1971: unsigned char name[1]; /* Length-prefixed name */
1972: } PROCSYMMIPS, *PROCPTRMIPS;
1973:
1974: /* generic block definition symbols */
1975: /* these are similar to the equivalent 16:16 or 16:32 symbols but */
1976: /* only define the length, type and linkage fields */
1977:
1978: typedef struct PROCSYM {
1979: unsigned short reclen; /* Record length */
1980: unsigned short rectyp; /* S_GPROC16 or S_LPROC16 */
1981: unsigned long pParent; /* pointer to the parent */
1982: unsigned long pEnd; /* pointer to this blocks end */
1983: unsigned long pNext; /* pointer to next symbol */
1984: } PROCSYM;
1985:
1986: typedef struct THUNKSYM {
1987: unsigned short reclen; /* Record length */
1988: unsigned short rectyp; /* S_THUNK */
1989: unsigned long pParent; /* pointer to the parent */
1990: unsigned long pEnd; /* pointer to this blocks end */
1991: unsigned long pNext; /* pointer to next symbol */
1992: } THUNKSYM;
1993:
1994: typedef struct BLOCKSYM {
1995: unsigned short reclen; /* Record length */
1996: unsigned short rectyp; /* S_BLOCK16 */
1997: unsigned long pParent; /* pointer to the parent */
1998: unsigned long pEnd; /* pointer to this blocks end */
1999: } BLOCKSYM;
2000:
2001: typedef struct WITHSYM {
2002: unsigned short reclen; /* Record length */
2003: unsigned short rectyp; /* S_WITH16 */
2004: unsigned long pParent; /* pointer to the parent */
2005: unsigned long pEnd; /* pointer to this blocks end */
2006: } WITHSYM;
2007:
2008: typedef enum CV_HREG_e {
2009: /*
2010: * Register set for the Intel 80x86 and ix86 processor series
2011: * (plus PCODE registers)
2012: */
2013:
2014: CV_REG_NONE = 0,
2015: CV_REG_AL = 1,
2016: CV_REG_CL = 2,
2017: CV_REG_DL = 3,
2018: CV_REG_BL = 4,
2019: CV_REG_AH = 5,
2020: CV_REG_CH = 6,
2021: CV_REG_DH = 7,
2022: CV_REG_BH = 8,
2023: CV_REG_AX = 9,
2024: CV_REG_CX = 10,
2025: CV_REG_DX = 11,
2026: CV_REG_BX = 12,
2027: CV_REG_SP = 13,
2028: CV_REG_BP = 14,
2029: CV_REG_SI = 15,
2030: CV_REG_DI = 16,
2031: CV_REG_EAX = 17,
2032: CV_REG_ECX = 18,
2033: CV_REG_EDX = 19,
2034: CV_REG_EBX = 20,
2035: CV_REG_ESP = 21,
2036: CV_REG_EBP = 22,
2037: CV_REG_ESI = 23,
2038: CV_REG_EDI = 24,
2039: CV_REG_ES = 25,
2040: CV_REG_CS = 26,
2041: CV_REG_SS = 27,
2042: CV_REG_DS = 28,
2043: CV_REG_FS = 29,
2044: CV_REG_GS = 30,
2045: CV_REG_IP = 31,
2046: CV_REG_FLAGS = 32,
2047: CV_REG_EIP = 33,
2048: CV_REG_EFLAGS = 34,
2049: CV_REG_TEMP = 40, /* PCODE Temp */
2050: CV_REG_TEMPH = 41, /* PCODE TempH */
2051: CV_REG_QUOTE = 42, /* PCODE Quote */
2052: CV_REG_PCDR3 = 43, /* PCODE reserved */
2053: CV_REG_PCDR4 = 44, /* PCODE reserved */
2054: CV_REG_PCDR5 = 45, /* PCODE reserved */
2055: CV_REG_PCDR6 = 46, /* PCODE reserved */
2056: CV_REG_PCDR7 = 47, /* PCODE reserved */
2057: CV_REG_CR0 = 80, /* CR0 -- control registers */
2058: CV_REG_CR1 = 81,
2059: CV_REG_CR2 = 82,
2060: CV_REG_CR3 = 83,
2061: CV_REG_DR0 = 90, /* Debug register */
2062: CV_REG_DR1 = 91,
2063: CV_REG_DR2 = 92,
2064: CV_REG_DR3 = 93,
2065: CV_REG_DR4 = 94,
2066: CV_REG_DR5 = 95,
2067: CV_REG_DR6 = 96,
2068: CV_REG_DR7 = 97,
2069: CV_REG_ST0 = 128,
2070: CV_REG_ST1 = 129,
2071: CV_REG_ST2 = 130,
2072: CV_REG_ST3 = 131,
2073: CV_REG_ST4 = 132,
2074: CV_REG_ST5 = 133,
2075: CV_REG_ST6 = 134,
2076: CV_REG_ST7 = 135,
2077: CV_REG_CTRL = 136,
2078: CV_REG_STAT = 137,
2079: CV_REG_TAG = 138,
2080: CV_REG_FPIP = 139,
2081: CV_REG_FPCS = 140,
2082: CV_REG_FPDO = 141,
2083: CV_REG_FPDS = 142,
2084: CV_REG_ISEM = 143,
2085: CV_REG_FPEIP = 144,
2086: CV_REG_FPEDO = 145,
2087:
2088: /*
2089: * registers for the 68K processors
2090: */
2091:
2092: CV_R68_D0 = 0,
2093: CV_R68_D1 = 1,
2094: CV_R68_D2 = 2,
2095: CV_R68_D3 = 3,
2096: CV_R68_D4 = 4,
2097: CV_R68_D5 = 5,
2098: CV_R68_D6 = 6,
2099: CV_R68_D7 = 7,
2100: CV_R68_A0 = 8,
2101: CV_R68_A1 = 9,
2102: CV_R68_A2 = 10,
2103: CV_R68_A3 = 11,
2104: CV_R68_A4 = 12,
2105: CV_R68_A5 = 13,
2106: CV_R68_A6 = 14,
2107: CV_R68_A7 = 15,
2108: CV_R68_CCR = 16,
2109: CV_R68_SR = 17,
2110: CV_R68_USP = 18,
2111: CV_R68_MSP = 19,
2112: CV_R68_SFC = 20,
2113: CV_R68_DFC = 21,
2114: CV_R68_CACR = 22,
2115: CV_R68_VBR = 23,
2116: CV_R68_CAAR = 24,
2117: CV_R68_ISP = 25,
2118: CV_R68_PC = 26,
2119: /* reserved 27 */
2120: CV_R68_FPCR = 28,
2121: CV_R68_FPSR = 29,
2122: CV_R68_FPIAR= 30,
2123: /* reserved 31 */
2124: CV_R68_FP0 = 32,
2125: CV_R68_FP1 = 33,
2126: CV_R68_FP2 = 34,
2127: CV_R68_FP3 = 35,
2128: CV_R68_FP4 = 36,
2129: CV_R68_FP5 = 37,
2130: CV_R68_FP6 = 38,
2131: CV_R68_FP7 = 39,
2132: /* reserved 40-50 */
2133: CV_R68_PSR = 51,
2134: CV_R68_PCSR = 52,
2135: CV_R68_VAL = 53,
2136: CV_R68_CRP = 54,
2137: CV_R68_SRP = 55,
2138: CV_R68_DRP = 56,
2139: CV_R68_TC = 57,
2140: CV_R68_AC = 58,
2141: CV_R68_SCC = 59,
2142: CV_R68_CAL = 60,
2143: CV_R68_TT0 = 61,
2144: CV_R68_TT1 = 62,
2145: /* reserved 63 */
2146: CV_R68_BAD0 = 64,
2147: CV_R68_BAD1 = 65,
2148: CV_R68_BAD2 = 66,
2149: CV_R68_BAD3 = 67,
2150: CV_R68_BAD4 = 68,
2151: CV_R68_BAD5 = 69,
2152: CV_R68_BAD6 = 70,
2153: CV_R68_BAD7 = 71,
2154: CV_R68_BAC0 = 72,
2155: CV_R68_BAC1 = 73,
2156: CV_R68_BAC2 = 74,
2157: CV_R68_BAC3 = 75,
2158: CV_R68_BAC4 = 76,
2159: CV_R68_BAC5 = 77,
2160: CV_R68_BAC6 = 78,
2161: CV_R68_BAC7 = 79,
2162:
2163: /*
2164: * Register set for the MIPS 4000
2165: */
2166:
2167: CV_M4_NOREG = CV_REG_NONE,
2168:
2169: CV_M4_IntZERO = 10, /* CPU REGISTER */
2170: CV_M4_IntAT = 11,
2171: CV_M4_IntV0 = 12,
2172: CV_M4_IntV1 = 13,
2173: CV_M4_IntA0 = 14,
2174: CV_M4_IntA1 = 15,
2175: CV_M4_IntA2 = 16,
2176: CV_M4_IntA3 = 17,
2177: CV_M4_IntT0 = 18,
2178: CV_M4_IntT1 = 19,
2179: CV_M4_IntT2 = 20,
2180: CV_M4_IntT3 = 21,
2181: CV_M4_IntT4 = 22,
2182: CV_M4_IntT5 = 23,
2183: CV_M4_IntT6 = 24,
2184: CV_M4_IntT7 = 25,
2185: CV_M4_IntS0 = 26,
2186: CV_M4_IntS1 = 27,
2187: CV_M4_IntS2 = 28,
2188: CV_M4_IntS3 = 29,
2189: CV_M4_IntS4 = 30,
2190: CV_M4_IntS5 = 31,
2191: CV_M4_IntS6 = 32,
2192: CV_M4_IntS7 = 33,
2193: CV_M4_IntT8 = 34,
2194: CV_M4_IntT9 = 35,
2195: CV_M4_IntKT0 = 36,
2196: CV_M4_IntKT1 = 37,
2197: CV_M4_IntGP = 38,
2198: CV_M4_IntSP = 39,
2199: CV_M4_IntS8 = 40,
2200: CV_M4_IntRA = 41,
2201: CV_M4_IntLO = 42,
2202: CV_M4_IntHI = 43,
2203:
2204: CV_M4_Fir = 50,
2205: CV_M4_Psr = 51,
2206:
2207: CV_M4_FltF0 = 60, /* Floating point registers */
2208: CV_M4_FltF1 = 61,
2209: CV_M4_FltF2 = 62,
2210: CV_M4_FltF3 = 63,
2211: CV_M4_FltF4 = 64,
2212: CV_M4_FltF5 = 65,
2213: CV_M4_FltF6 = 66,
2214: CV_M4_FltF7 = 67,
2215: CV_M4_FltF8 = 68,
2216: CV_M4_FltF9 = 69,
2217: CV_M4_FltF10 = 70,
2218: CV_M4_FltF11 = 71,
2219: CV_M4_FltF12 = 72,
2220: CV_M4_FltF13 = 73,
2221: CV_M4_FltF14 = 74,
2222: CV_M4_FltF15 = 75,
2223: CV_M4_FltF16 = 76,
2224: CV_M4_FltF17 = 77,
2225: CV_M4_FltF18 = 78,
2226: CV_M4_FltF19 = 79,
2227: CV_M4_FltF20 = 80,
2228: CV_M4_FltF21 = 81,
2229: CV_M4_FltF22 = 82,
2230: CV_M4_FltF23 = 83,
2231: CV_M4_FltF24 = 84,
2232: CV_M4_FltF25 = 85,
2233: CV_M4_FltF26 = 86,
2234: CV_M4_FltF27 = 87,
2235: CV_M4_FltF28 = 88,
2236: CV_M4_FltF29 = 89,
2237: CV_M4_FltF30 = 90,
2238: CV_M4_FltF31 = 92,
2239: CV_M4_FltFsr = 93,
2240:
2241: /*
2242: * Register set for the ALPHA AXP
2243: */
2244:
2245: CV_ALPHA_NOREG = CV_REG_NONE,
2246:
2247: CV_ALPHA_FltF0 = 10, /* Floating point registers */
2248: CV_ALPHA_FltF1, // 11
2249: CV_ALPHA_FltF2, // 12
2250: CV_ALPHA_FltF3, // 13
2251: CV_ALPHA_FltF4, // 14
2252: CV_ALPHA_FltF5, // 15
2253: CV_ALPHA_FltF6, // 16
2254: CV_ALPHA_FltF7, // 17
2255: CV_ALPHA_FltF8, // 18
2256: CV_ALPHA_FltF9, // 19
2257: CV_ALPHA_FltF10, // 20
2258: CV_ALPHA_FltF11, // 21
2259: CV_ALPHA_FltF12, // 22
2260: CV_ALPHA_FltF13, // 23
2261: CV_ALPHA_FltF14, // 24
2262: CV_ALPHA_FltF15, // 25
2263: CV_ALPHA_FltF16, // 26
2264: CV_ALPHA_FltF17, // 27
2265: CV_ALPHA_FltF18, // 28
2266: CV_ALPHA_FltF19, // 29
2267: CV_ALPHA_FltF20, // 30
2268: CV_ALPHA_FltF21, // 31
2269: CV_ALPHA_FltF22, // 32
2270: CV_ALPHA_FltF23, // 33
2271: CV_ALPHA_FltF24, // 34
2272: CV_ALPHA_FltF25, // 35
2273: CV_ALPHA_FltF26, // 36
2274: CV_ALPHA_FltF27, // 37
2275: CV_ALPHA_FltF28, // 38
2276: CV_ALPHA_FltF29, // 39
2277: CV_ALPHA_FltF30, // 30
2278: CV_ALPHA_FltF31, // 41
2279:
2280: CV_ALPHA_IntV0, // 42 Integer registers
2281: CV_ALPHA_IntT0, // 43
2282: CV_ALPHA_IntT1, // 44
2283: CV_ALPHA_IntT2, // 45
2284: CV_ALPHA_IntT3, // 46
2285: CV_ALPHA_IntT4, // 47
2286: CV_ALPHA_IntT5, // 48
2287: CV_ALPHA_IntT6, // 49
2288: CV_ALPHA_IntT7, // 50
2289: CV_ALPHA_IntS0, // 51
2290: CV_ALPHA_IntS1, // 52
2291: CV_ALPHA_IntS2, // 53
2292: CV_ALPHA_IntS3, // 54
2293: CV_ALPHA_IntS4, // 55
2294: CV_ALPHA_IntS5, // 56
2295: CV_ALPHA_IntFP, // 57
2296: CV_ALPHA_IntA0, // 58
2297: CV_ALPHA_IntA1, // 59
2298: CV_ALPHA_IntA2, // 60
2299: CV_ALPHA_IntA3, // 61
2300: CV_ALPHA_IntA4, // 62
2301: CV_ALPHA_IntA5, // 63
2302: CV_ALPHA_IntT8, // 64
2303: CV_ALPHA_IntT9, // 65
2304: CV_ALPHA_IntT10, // 66
2305: CV_ALPHA_IntT11, // 67
2306: CV_ALPHA_IntRA, // 68
2307: CV_ALPHA_IntT12, // 69
2308: CV_ALPHA_IntAT, // 70
2309: CV_ALPHA_IntGP, // 71
2310: CV_ALPHA_IntSP, // 72
2311: CV_ALPHA_IntZERO, // 73
2312:
2313:
2314: CV_ALPHA_Fpcr, // 74 Control registers
2315: CV_ALPHA_Fir, // 75
2316: CV_ALPHA_Psr, // 76
2317: CV_ALPHA_FltFsr // 77
2318:
2319: } CV_HREG_e;
2320:
2321:
2322: #pragma pack()
2323:
2324: #endif /* CV_INFO_INCLUDED */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.