Changes to work towards compatability with IBM's version of dyninst.
[dyninst.git] / dyninstAPI / h / BPatch_type.h
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 #ifndef _BPatch_type_h_
43 #define _BPatch_type_h_
44
45 #include "BPatch_dll.h"
46 #include "BPatch_Vector.h"
47 #include <string.h>
48
49 typedef enum {BPatchSymLocalVar,  BPatchSymGlobalVar, BPatchSymRegisterVar,
50               BPatchSymStaticLocalVar, BPatchSymStaticGlobal,
51               BPatchSymLocalFunc, BPatchSymGlobalFunc, BPatchSymFuncParam,
52               BPatchSymTypeName, BPatchSymAggType, BPatchSymTypeTag}symDescr_t;
53
54 /*
55  * Symbol Descriptors:
56  * BPatchSymLocalVar       - local variable- gnu sun-(empty)
57  * BPatchSymGlobalVar      - global variable- gnu sun-'G'
58  * BPatchSymRegisterVar    - register variable- gnu sun-'r'
59  * BPatchSymStaticLocalVar - static local variable- gnu sun-'V'
60  * BPatchSymStaticGlobal   - static global variable- gnu- sun'S'
61  * BPatchSymLocalFunc      - local function- gnu sun-'f'
62  * BPatchSymGlobalFunc     - global function- gnu- sun'F'
63  * BPatchSymFuncParam      - function paramater - gnu- sun'p'
64  * BPatchSymTypeName       - type name- gnu sun-'t'
65  * BPatchSymAggType        - aggregate type-struct,union, enum- gnu sun-'T'
66  * BPatchSymTypeTag        - C++ type name and tag combination
67  */
68
69 typedef enum {BPatch_dataScalar, 
70               BPatch_dataEnumerated,
71               BPatch_dataTypeClass,
72               BPatch_dataStructure, 
73               BPatch_dataUnion, 
74               BPatch_dataArray, 
75               BPatch_dataPointer, 
76               BPatch_dataReferance, 
77               BPatch_dataFunction,
78               BPatch_dataTypeAttrib,
79               BPatch_dataBuilt_inType,
80               BPatch_dataReference,
81               BPatch_dataUnknownType,
82               BPatchSymTypeRange,
83               BPatch_dataMethod,
84               BPatch_dataCommon,
85               BPatch_dataPrimitive,
86               BPatch_dataTypeNumber,
87 } BPatch_dataClass;
88
89
90 #define BPatch_scalar   BPatch_dataScalar
91 #define BPatch_enumerated       BPatch_dataEnumerated
92 #define BPatch_typeClass        BPatch_dataTypeClass
93 #define BPatch_structure        BPatch_dataStructure 
94 #define BPatch_union    BPatch_dataUnion 
95 #define BPatch_array    BPatch_dataArray 
96 #define BPatch_pointer  BPatch_dataPointer 
97 #define BPatch_reference        BPatch_dataReferance 
98 #define BPatch_typeAttrib       BPatch_dataTypeAttrib
99 #define BPatch_built_inType     BPatch_dataBuilt_inType
100 #define BPatch_unknownType      BPatch_dataUnknownType
101
102 /*
103  * Type Descriptors:
104  * BPatchSymTypeReference - type reference- gnu sun-(empty)
105  * BPatch_dataArray - array type- gnu sun-'a'
106  * BPatch_dataEnumerated - enumerated type- gnu sun-'e'
107  * BPatch_dataTypeClass - Class type
108  * BPatch_dataFunction - function type- gnu sun-'f'
109  * BPatchSymTypeRange - range type- gnu sun-'r'
110  * BPatch_dataStructure - structure type- gnu sun-'s'
111  * BPatch_dataUnion - union specification- gnu sun-'u'
112  * BPatch_dataPointer - pointer type- gnu sun-'*'
113  * BPatch_dataReferance - referance type- gnu sun-'*'
114  * BPatch_dataTypeAttrib - type attribute (C++)- gnu sun- '@'
115  * BPatch_dataBuilt_inType - built-in type -- gdb doc ->negative type number
116  * BPatch_dataReference - C++ reference to another type- gnu sun- '&'
117  * BPatch_dataMethod - C++ class method
118  */
119
120 typedef enum {BPatch_private, BPatch_protected, BPatch_public,
121               BPatch_optimized=9,BPatch_visUnknown}BPatch_visibility;
122 /*
123  * BPatch_visibility: Accessibility of member data and functions
124  * These values follow the 'field_name:' after the '/' identifier.
125  * BPatch_private   == 0 gnu Sun -- private
126  * BPatch_protected == 1 gnu Sun -- protected
127  * BPatch_public    == 2 gnu Sun -- public
128  * BPatch_optimized == 9 gnu Sun -- field optimized out and is public
129  * BPatch_visUnknown visibility not known or doesn't apply(ANSIC), the default
130  *
131  */
132
133 class BPatch_type;
134 class BPatch_function;
135
136 /*
137  * A BPatch_field is equivalent to a field in a enum, struct, or union.
138  * A field can be an atomic type, i.e, int, char, or more complex like a
139  * union or struct.  
140  */
141 class BPATCH_DLL_EXPORT BPatch_field {
142   friend class BPatch_variableExpr;
143
144   char *fieldname;
145   BPatch_dataClass   typeDes;
146   BPatch_visibility  vis;
147   /* For Enums */
148   int          value;
149
150   /* For structs and unions */
151   BPatch_type *_type;
152   int         offset;
153   int         size;
154
155   /* Method vars */
156   
157 public:
158   
159   // Enum constructor
160   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, int eValue);
161   // C++ version for Enum constructor
162   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, int eValue,
163                BPatch_visibility _vis);     
164   // Struct or Union construct
165   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, 
166                BPatch_type *suType, int suOffset, int suSize);
167   // C++ version for Struct or Union construct
168   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, 
169                BPatch_type *suType, int suOffset, int suSize,
170                BPatch_visibility _vis);
171   
172   
173                               
174   const char *getName() { return fieldname; } 
175   BPatch_type *getType() { return _type; }
176
177   int getValue() { return value;}
178   BPatch_visibility getVisibility() { return vis; }
179   BPatch_dataClass getTypeDesc() { return typeDes; }
180   int getSize() { return size; }
181   int getOffset() { return offset; }
182 }; 
183
184 //
185 // Define an instance of a Common block.  Each subroutine can have its own
186 //   version of the common block.
187 //
188 class BPATCH_DLL_EXPORT BPatch_cblock {
189    friend BPatch_type;
190
191 private:
192   // the list of fields
193   BPatch_Vector<BPatch_field *> fieldList;
194
195   // which functions use this list
196   BPatch_Vector<BPatch_function *> functions;
197
198 public:
199   BPatch_Vector<BPatch_field *> *getComponents() { return &fieldList; }
200   BPatch_Vector<BPatch_function *> *getFunctions() { return &functions; }
201 };
202
203 class BPATCH_DLL_EXPORT BPatch_type {
204 private:
205   bool          nullType;
206   char          *name;
207   int           ID;                /* unique ID of type */
208   int           size;              /* size of type */
209   char          *low;               /* lower bound */
210   char          *hi;                /* upper bound */
211   
212   BPatch_dataClass   type_;
213   BPatch_type   *ptr;               /* pointer to other type (for ptrs, arrays) */
214
215   /* For enums, structs and union components */
216   BPatch_Vector<BPatch_field *> fieldList;
217
218   /* For common blocks */
219   BPatch_Vector<BPatch_cblock *> *cblocks;
220   
221 public:
222 // Start Internal Functions
223   BPatch_type();
224   
225   BPatch_type(const char *_name, bool _nullType = false);
226   /* Enum constructor */
227   BPatch_type(const char *_name, int _ID,  BPatch_dataClass _type);
228   /* Struct, union, range(size), reference(void) constructor and
229      Built-in type constructor-negative type numbers defined by gdb doc */
230   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type, int _size);
231   /* Pointer (internal) constructor */
232   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
233               BPatch_type * _ptr);
234   /* Range (lower and uper bound) constructor */
235   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
236               const char * _low, const char * _hi);
237   /* Array Constructor */
238   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
239               BPatch_type * _ptr, int _low, int _hi);
240   /* Pre-existing type--typedef */
241   BPatch_type(const char *_name, int _ID, BPatch_type * _ptr);
242   /* defining a type in terms of a builtin type (Type Attribute) */
243   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
244               int _size, BPatch_type * _ptr);
245
246    /* Add field for Enum */
247   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, int value);
248   /* Add field for C++(has visibility) Enum */
249   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, int value,
250                 BPatch_visibility _vis);
251   /* Add field for struct or union */
252   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, 
253       BPatch_type *_type, int _offset, int _size);
254   /* Add field for C++(has visibility) struct or union */
255   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, 
256       BPatch_type *_type, int _offset, int _size, BPatch_visibility _vis);
257   
258  void beginCommonBlock();
259  void endCommonBlock(BPatch_function *, void *baseAddr);
260
261  // END Internal Functions
262
263       
264  // Constructors for USER DEFINED BPatch_types
265   /* Enum constructor */
266   BPatch_type(const char *_name, BPatch_dataClass _type);
267   /* Struct, union, range(size), reference(void) constructor and
268      Built-in type constructor-negative type numbers defined by gdb doc */
269   BPatch_type(const char *_name, BPatch_dataClass _type, int _size);
270   /* Pointer (internal) constructor */
271   BPatch_type(const char *_name, BPatch_type * _ptr, int size_);
272   /* Range (lower and uper bound) constructor */
273   BPatch_type(const char *_name, BPatch_dataClass _type,
274               const char * _low, const char * _hi);
275   /* Array Constructor */
276   BPatch_type(const char *_name, BPatch_dataClass _type,
277               BPatch_type * _ptr, int _low, int _hi);
278   /* Pre-existing type--typedef */
279   BPatch_type(const char *_name, BPatch_type * _ptr);
280   /* defining a type in terms of a builtin type (Type Attribute) */
281   BPatch_type(const char *_name, BPatch_dataClass _type, int _size,
282               BPatch_type * _ptr);
283                             
284   int  getID(){ return ID;}
285   void setID(int typeId) { ID = typeId; }
286   void setDataClass(BPatch_dataClass p1) { type_ = p1; }
287
288   int getSize() const { return size; };
289   const char *getName() { return name; }
290
291 #ifdef IBM_BPATCH_COMPAT
292   const char *getName(char *buffer, int max) { return strncpy(buffer, name, max); }
293   BPatch_dataClass type() { return type_; }
294 #endif
295
296   const char *getLow() { return low; }
297   const char *getHigh() { return hi; }
298   BPatch_type *getConstituentType() { return ptr; }
299   bool isCompatible(BPatch_type *otype);
300   BPatch_dataClass getDataClass() { return type_; }
301   BPatch_Vector<BPatch_field *> *getComponents() { 
302       return &fieldList; }
303   BPatch_Vector<BPatch_cblock *> *getCblocks() { return cblocks; }
304 };
305
306
307 //
308 // This class stores information about local variables.
309 // It is desgined store information about a variable in a function.
310 // Scope needs to be addressed in this class.
311
312 class BPATCH_DLL_EXPORT BPatch_localVar{
313   char * name;
314   BPatch_type * type;
315   int lineNum;
316   int frameOffset;
317
318   //USed only in XCOFF/COFF format, can be 
319   //   scAbs=5, 
320   //   scRegister, scVarRegister, 
321   //   scVar=0
322
323   int storageClass; 
324
325   bool frameRelative;
326   // scope_t scope;
327   
328 public:
329   
330   BPatch_localVar(char * _name,  BPatch_type * _type, int _lineNum,
331                   int _frameOffset, int _sc = 5 /* scAbs */, bool fr=true);
332   ~BPatch_localVar();
333
334   const char *  getName()        { return name; }
335   BPatch_type * getType()        { return type; }
336   int           getLineNum()     { return lineNum; }
337   int           getFrameOffset() { return frameOffset; }
338   int           getFrameRelative() { return frameRelative; }
339   int           getSc()          { return storageClass; }
340   
341 };
342
343 #endif /* _BPatch_type_h_ */