Added DLL linkage specification to class declarations to support building
[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
48 typedef enum {BPatchSymLocalVar,  BPatchSymGlobalVar, BPatchSymRegisterVar,
49               BPatchSymStaticLocalVar, BPatchSymStaticGlobal,
50               BPatchSymLocalFunc, BPatchSymGlobalFunc, BPatchSymFuncParam,
51               BPatchSymTypeName, BPatchSymAggType, BPatchSymTypeTag}symDescr_t;
52
53 /*
54  * Symbol Descriptors:
55  * BPatchSymLocalVar       - local variable- gnu sun-(empty)
56  * BPatchSymGlobalVar      - global variable- gnu sun-'G'
57  * BPatchSymRegisterVar    - register variable- gnu sun-'r'
58  * BPatchSymStaticLocalVar - static local variable- gnu sun-'V'
59  * BPatchSymStaticGlobal   - static global variable- gnu- sun'S'
60  * BPatchSymLocalFunc      - local function- gnu sun-'f'
61  * BPatchSymGlobalFunc     - global function- gnu- sun'F'
62  * BPatchSymFuncParam      - function paramater - gnu- sun'p'
63  * BPatchSymTypeName       - type name- gnu sun-'t'
64  * BPatchSymAggType        - aggregate type-struct,union, enum- gnu sun-'T'
65  * BPatchSymTypeTag        - C++ type name and tag combination
66  */
67
68 typedef enum {BPatch_scalar, 
69               BPatch_enumerated,
70               BPatch_class,
71               BPatch_structure, 
72               BPatch_union, 
73               BPatch_array, 
74               BPatch_pointer, 
75               BPatch_referance, 
76               BPatch_func,
77               BPatch_typeAttrib,
78               BPatch_built_inType,
79               BPatch_reference,
80               BPatch_unknownType,
81               BPatchSymTypeRange,
82               BPatch_method,
83               BPatch_common} BPatch_dataClass;
84
85 /*
86  * Type Descriptors:
87  * BPatchSymTypeReference - type reference- gnu sun-(empty)
88  * BPatch_array - array type- gnu sun-'a'
89  * BPatch_enumerated - enumerated type- gnu sun-'e'
90  * BPatch_class - Class type
91  * BPatch_func - function type- gnu sun-'f'
92  * BPatchSymTypeRange - range type- gnu sun-'r'
93  * BPatch_structure - structure type- gnu sun-'s'
94  * BPatch_union - union specification- gnu sun-'u'
95  * BPatch_pointer - pointer type- gnu sun-'*'
96  * BPatch_referance - referance type- gnu sun-'*'
97  * BPatch_typeAttrib - type attribute (C++)- gnu sun- '@'
98  * BPatch_built_inType - built-in type -- gdb doc ->negative type number
99  * BPatch_reference - C++ reference to another type- gnu sun- '&'
100  * BPatch_method - C++ class method
101  */
102
103 typedef enum {BPatch_private, BPatch_protected, BPatch_public,
104               BPatch_optimized=9,BPatch_visUnknown}BPatch_visibility;
105 /*
106  * BPatch_visibility: Accessibility of member data and functions
107  * These values follow the 'field_name:' after the '/' identifier.
108  * BPatch_private   == 0 gnu Sun -- private
109  * BPatch_protected == 1 gnu Sun -- protected
110  * BPatch_public    == 2 gnu Sun -- public
111  * BPatch_optimized == 9 gnu Sun -- field optimized out and is public
112  * BPatch_visUnknown visibility not known or doesn't apply(ANSIC), the default
113  *
114  */
115
116 class BPatch_type;
117 class BPatch_function;
118
119 /*
120  * A BPatch_field is equivalent to a field in a enum, struct, or union.
121  * A field can be an atomic type, i.e, int, char, or more complex like a
122  * union or struct.  
123  */
124 class BPATCH_DLL_EXPORT BPatch_field {
125   friend class BPatch_variableExpr;
126
127   char *fieldname;
128   BPatch_dataClass   typeDes;
129   BPatch_visibility  vis;
130   /* For Enums */
131   int          value;
132
133   /* For structs and unions */
134   BPatch_type *type;
135   int         offset;
136   int         size;
137
138   /* Method vars */
139   
140 public:
141   
142   // Enum constructor
143   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, int eValue);
144   // C++ version for Enum constructor
145   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, int eValue,
146                BPatch_visibility _vis);     
147   // Struct or Union construct
148   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, 
149                BPatch_type *suType, int suOffset, int suSize);
150   // C++ version for Struct or Union construct
151   BPatch_field(const char * fName,  BPatch_dataClass _typeDes, 
152                BPatch_type *suType, int suOffset, int suSize,
153                BPatch_visibility _vis);
154   
155   
156                               
157   const char *getName() { return fieldname; } 
158   BPatch_type *getType() { return type; }
159   int getValue() { return value;}
160   BPatch_visibility getVisibility() { return vis; }
161   BPatch_dataClass getTypeDesc() { return typeDes; }
162   int getSize() { return size; }
163   int getOffset() { return offset; }
164 }; 
165
166 //
167 // Define an instance of a Common block.  Each subroutine can have its own
168 //   version of the common block.
169 //
170 class BPATCH_DLL_EXPORT BPatch_cblock {
171    friend BPatch_type;
172
173 private:
174   // the list of fields
175   BPatch_Vector<BPatch_field *> fieldList;
176
177   // which functions use this list
178   BPatch_Vector<BPatch_function *> functions;
179
180 public:
181   BPatch_Vector<BPatch_field *> *getComponents() { return &fieldList; }
182   BPatch_Vector<BPatch_function *> *getFunctions() { return &functions; }
183 };
184
185 class BPATCH_DLL_EXPORT BPatch_type {
186 private:
187   bool          nullType;
188   char          *name;
189   int           ID;                /* unique ID of type */
190   int           size;              /* size of type */
191   char          *low;               /* lower bound */
192   char          *hi;                /* upper bound */
193   
194   BPatch_dataClass   type_;
195   BPatch_type   *ptr;               /* pointer to other type (for ptrs, arrays) */
196
197   /* For enums, structs and union components */
198   BPatch_Vector<BPatch_field *> fieldList;
199
200   /* For common blocks */
201   BPatch_Vector<BPatch_cblock *> *cblocks;
202   
203 public:
204 // Start Internal Functions
205   BPatch_type();
206   
207   BPatch_type(const char *_name, bool _nullType = false);
208   /* Enum constructor */
209   BPatch_type(const char *_name, int _ID,  BPatch_dataClass _type);
210   /* Struct, union, range(size), reference(void) constructor and
211      Built-in type constructor-negative type numbers defined by gdb doc */
212   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type, int _size);
213   /* Pointer (internal) constructor */
214   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
215               BPatch_type * _ptr);
216   /* Range (lower and uper bound) constructor */
217   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
218               const char * _low, const char * _hi);
219   /* Array Constructor */
220   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
221               BPatch_type * _ptr, int _low, int _hi);
222   /* Pre-existing type--typedef */
223   BPatch_type(const char *_name, int _ID, BPatch_type * _ptr);
224   /* defining a type in terms of a builtin type (Type Attribute) */
225   BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
226               int _size, BPatch_type * _ptr);
227
228    /* Add field for Enum */
229   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, int value);
230   /* Add field for C++(has visibility) Enum */
231   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, int value,
232                 BPatch_visibility _vis);
233   /* Add field for struct or union */
234   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, 
235       BPatch_type *_type, int _offset, int _size);
236   /* Add field for C++(has visibility) struct or union */
237   void addField(const char * _fieldname,  BPatch_dataClass _typeDes, 
238       BPatch_type *_type, int _offset, int _size, BPatch_visibility _vis);
239   
240  void beginCommonBlock();
241  void endCommonBlock(BPatch_function *, void *baseAddr);
242
243  // END Internal Functions
244
245       
246  // Constructors for USER DEFINED BPatch_types
247   /* Enum constructor */
248   BPatch_type(const char *_name, BPatch_dataClass _type);
249   /* Struct, union, range(size), reference(void) constructor and
250      Built-in type constructor-negative type numbers defined by gdb doc */
251   BPatch_type(const char *_name, BPatch_dataClass _type, int _size);
252   /* Pointer (internal) constructor */
253   BPatch_type(const char *_name, BPatch_type * _ptr, int size_);
254   /* Range (lower and uper bound) constructor */
255   BPatch_type(const char *_name, BPatch_dataClass _type,
256               const char * _low, const char * _hi);
257   /* Array Constructor */
258   BPatch_type(const char *_name, BPatch_dataClass _type,
259               BPatch_type * _ptr, int _low, int _hi);
260   /* Pre-existing type--typedef */
261   BPatch_type(const char *_name, BPatch_type * _ptr);
262   /* defining a type in terms of a builtin type (Type Attribute) */
263   BPatch_type(const char *_name, BPatch_dataClass _type, int _size,
264               BPatch_type * _ptr);
265                             
266   int  getID(){ return ID;}
267   void setID(int typeId) { ID = typeId; }
268   void setDataClass(BPatch_dataClass p1) { type_ = p1; }
269
270   int getSize() const { return size; };
271   const char *getName() { return name; }
272   const char *getLow() { return low; }
273   const char *getHigh() { return hi; }
274   BPatch_type *getConstituentType() { return ptr; }
275   bool isCompatible(BPatch_type *otype);
276   BPatch_dataClass getDataClass() { return type_; }
277   BPatch_Vector<BPatch_field *> *getComponents() { 
278       return &fieldList; }
279   BPatch_Vector<BPatch_cblock *> *getCblocks() { return cblocks; }
280 };
281
282
283 //
284 // This class stores information about local variables.
285 // It is desgined store information about a variable in a function.
286 // Scope needs to be addressed in this class.
287
288 class BPATCH_DLL_EXPORT BPatch_localVar{
289   char * name;
290   BPatch_type * type;
291   int lineNum;
292   int frameOffset;
293
294   //USed only in XCOFF/COFF format, can be 
295   //   scAbs=5, 
296   //   scRegister, scVarRegister, 
297   //   scVar=0
298
299   int storageClass; 
300
301   bool frameRelative;
302   // scope_t scope;
303   
304 public:
305   
306   BPatch_localVar(char * _name,  BPatch_type * _type, int _lineNum,
307                   int _frameOffset, int _sc = 5 /* scAbs */, bool fr=true);
308   ~BPatch_localVar();
309
310   const char *  getName()        { return name; }
311   BPatch_type * getType()        { return type; }
312   int           getLineNum()     { return lineNum; }
313   int           getFrameOffset() { return frameOffset; }
314   int           getFrameRelative() { return frameRelative; }
315   int           getSc()          { return storageClass; }
316   
317 };
318
319 #endif /* _BPatch_type_h_ */