Update copyright
[dyninst.git] / dataflowAPI / rose / SgAsmExpression.h
1 #if !defined(SG_ASM_EXPR_H)
2 #define SG_ASM_EXPR_H
3
4 #include "external/rose/rose-compat.h"
5 #include "SgNode.h"
6 #include "SgAsmType.h"
7 #include "external/rose/powerpcInstructionEnum.h"
8
9
10 #if defined(_MSC_VER)
11 #include "external/stdint-win.h"
12 #include "external/inttypes-win.h"
13 #elif defined(os_solaris)
14 #include <inttypes.h>
15 #else
16 #include <stdint.h>
17 #include <inttypes.h>
18 #endif
19
20
21 class SgAsmExpression : public SgNode {
22  public:
23     virtual SgAsmType* get_type();
24
25     /*! \brief returns a string representing the class name */
26     virtual std::string class_name() const;
27     
28     /*! \brief returns new style SageIII enum values */
29     virtual VariantT variantT() const; // MS: new variant used in tree traversal
30     
31     /*! \brief static variant value */
32     static const VariantT static_variant = V_SgAsmExpression;
33     
34     /* the generated cast function */
35     /*! \brief Casts pointer from base class to derived class */
36     friend       SgAsmExpression* isSgAsmExpression(       SgNode * s );
37     /*! \brief Casts pointer from base class to derived class (for const pointers) */
38     friend const SgAsmExpression* isSgAsmExpression( const SgNode * s );
39     
40     
41     std::string get_replacement() const;
42     void set_replacement(std::string replacement);
43     
44     std::string get_comment() const;
45     void set_comment(std::string comment);
46
47     virtual ~SgAsmExpression();
48     
49     SgAsmExpression(); 
50     
51  protected:
52     std::string p_replacement;
53     
54     std::string p_comment;
55 };
56
57 // Class Definition for SgAsmValueExpression
58 class SgAsmValueExpression : public SgAsmExpression {
59  public:
60     virtual SgAsmType* get_type();
61
62     virtual std::string class_name() const;
63     
64     /*! \brief returns new style SageIII enum values */
65     virtual VariantT variantT() const; // MS: new variant used in tree traversal
66     
67     /*! \brief static variant value */
68     static const VariantT static_variant = V_SgAsmValueExpression;
69     
70     /* the generated cast function */
71     /*! \brief Casts pointer from base class to derived class */
72     friend       SgAsmValueExpression* isSgAsmValueExpression(       SgNode * s );
73     /*! \brief Casts pointer from base class to derived class (for const pointers) */
74     friend const SgAsmValueExpression* isSgAsmValueExpression( const SgNode * s );
75     
76  public: 
77     SgAsmValueExpression* get_unfolded_expression_tree() const;
78     void set_unfolded_expression_tree(SgAsmValueExpression* unfolded_expression_tree);
79     
80  public: 
81     unsigned short get_bit_offset() const;
82     void set_bit_offset(unsigned short bit_offset);
83     
84  public: 
85     unsigned short get_bit_size() const;
86     void set_bit_size(unsigned short bit_size);
87     
88     
89  public: 
90     virtual ~SgAsmValueExpression();
91     
92     
93  public: 
94     SgAsmValueExpression(); 
95     
96  protected:
97     // Start of memberFunctionString
98     SgAsmValueExpression* p_unfolded_expression_tree;
99     
100     // End of memberFunctionString
101     // Start of memberFunctionString
102     unsigned short p_bit_offset;
103     
104     // End of memberFunctionString
105     // Start of memberFunctionString
106     unsigned short p_bit_size;  
107
108     
109     // End of memberFunctionString
110 };
111
112 class SgAsmByteValueExpression : public SgAsmValueExpression {
113  public:
114         virtual SgAsmType* get_type();
115     /*! \brief returns a string representing the class name */
116     virtual std::string class_name() const;
117     
118     /*! \brief returns new style SageIII enum values */
119     virtual VariantT variantT() const; // MS: new variant used in tree traversal
120     
121     /*! \brief static variant value */
122     static const VariantT static_variant = V_SgAsmByteValueExpression;
123     
124     /* the generated cast function */
125     /*! \brief Casts pointer from base class to derived class */
126     friend       SgAsmByteValueExpression* isSgAsmByteValueExpression(       SgNode * s );
127     /*! \brief Casts pointer from base class to derived class (for const pointers) */
128     friend const SgAsmByteValueExpression* isSgAsmByteValueExpression( const SgNode * s );
129     
130  public: 
131     uint8_t get_value() const;
132     void set_value(uint8_t value);
133     
134     
135  public: 
136     virtual ~SgAsmByteValueExpression();
137     
138     
139  public: 
140     SgAsmByteValueExpression(uint8_t value = 0x0); 
141     
142  protected:
143     // Start of memberFunctionString
144     uint8_t p_value;
145 };
146
147 class SgAsmWordValueExpression : public SgAsmValueExpression {
148  public:
149         virtual SgAsmType* get_type();
150    /*! \brief returns a string representing the class name */
151     virtual std::string class_name() const;
152     
153     /*! \brief returns new style SageIII enum values */
154     virtual VariantT variantT() const; // MS: new variant used in tree traversal
155     
156     /*! \brief static variant value */
157     static const VariantT static_variant = V_SgAsmWordValueExpression;
158     
159     /* the generated cast function */
160     /*! \brief Casts pointer from base class to derived class */
161     friend       SgAsmWordValueExpression* isSgAsmWordValueExpression(       SgNode * s );
162     /*! \brief Casts pointer from base class to derived class (for const pointers) */
163     friend const SgAsmWordValueExpression* isSgAsmWordValueExpression( const SgNode * s );
164     
165  public: 
166     uint16_t get_value() const;
167     void set_value(uint16_t value);
168     
169     
170  public: 
171     virtual ~SgAsmWordValueExpression();
172     
173     
174  public: 
175     SgAsmWordValueExpression(uint16_t value = 0x0); 
176     
177  protected:
178     // Start of memberFunctionString
179     uint16_t p_value;
180 };
181
182 // Class Definition for SgAsmDoubleWordValueExpression
183 class SgAsmDoubleWordValueExpression : public SgAsmValueExpression {
184  public:
185         virtual SgAsmType* get_type();
186    /*! \brief returns a string representing the class name */
187     virtual std::string class_name() const;
188     
189     /*! \brief returns new style SageIII enum values */
190     virtual VariantT variantT() const; // MS: new variant used in tree traversal
191     
192     /*! \brief static variant value */
193     static const VariantT static_variant = V_SgAsmDoubleWordValueExpression;
194     
195     /* the generated cast function */
196     /*! \brief Casts pointer from base class to derived class */
197     friend       SgAsmDoubleWordValueExpression* isSgAsmDoubleWordValueExpression(       SgNode * s );
198     /*! \brief Casts pointer from base class to derived class (for const pointers) */
199     friend const SgAsmDoubleWordValueExpression* isSgAsmDoubleWordValueExpression( const SgNode * s );
200     
201  public: 
202     uint32_t get_value() const;
203     void set_value(uint32_t value);
204     
205     
206  public: 
207     virtual ~SgAsmDoubleWordValueExpression();
208     
209     
210  public: 
211     SgAsmDoubleWordValueExpression(uint32_t value = 0x0); 
212     
213  protected:
214     // Start of memberFunctionString
215     uint32_t p_value;
216     
217 };
218
219 class SgAsmQuadWordValueExpression : public SgAsmValueExpression {
220  public:
221         virtual SgAsmType* get_type();
222    
223     /*! \brief returns a string representing the class name */
224     virtual std::string class_name() const;
225     
226     /*! \brief returns new style SageIII enum values */
227     virtual VariantT variantT() const; // MS: new variant used in tree traversal
228     
229     /*! \brief static variant value */
230     static const VariantT static_variant = V_SgAsmQuadWordValueExpression;
231     
232     /* the generated cast function */
233     /*! \brief Casts pointer from base class to derived class */
234     friend       SgAsmQuadWordValueExpression* isSgAsmQuadWordValueExpression(       SgNode * s );
235     /*! \brief Casts pointer from base class to derived class (for const pointers) */
236     friend const SgAsmQuadWordValueExpression* isSgAsmQuadWordValueExpression( const SgNode * s );
237     
238     
239     // End of memberFunctionString
240     
241  public: 
242     uint64_t get_value() const;
243     void set_value(uint64_t value);
244     
245     
246  public: 
247     virtual ~SgAsmQuadWordValueExpression();
248     
249     
250  public: 
251     SgAsmQuadWordValueExpression(uint64_t value = 0x0); 
252     
253  protected:
254     // Start of memberFunctionString
255     uint64_t p_value;
256     
257     // End of memberFunctionString
258 };
259
260 class SgAsmSingleFloatValueExpression : public SgAsmValueExpression {
261  public:
262         virtual SgAsmType* get_type();
263
264     // virtual SgNode* copy ( const SgCopyHelp & help) const;
265
266     /*! \brief returns a string representing the class name */
267     virtual std::string class_name() const;
268
269     /*! \brief returns new style SageIII enum values */
270     virtual VariantT variantT() const; // MS: new variant used in tree traversal
271
272     /*! \brief static variant value */
273     static const VariantT static_variant = V_SgAsmSingleFloatValueExpression;
274
275     /* the generated cast function */
276     /*! \brief Casts pointer from base class to derived class */
277     friend       SgAsmSingleFloatValueExpression* isSgAsmSingleFloatValueExpression(       SgNode * s );
278     /*! \brief Casts pointer from base class to derived class (for const pointers) */
279     friend const SgAsmSingleFloatValueExpression* isSgAsmSingleFloatValueExpression( const SgNode * s );
280
281  public: 
282     float get_value() const;
283     void set_value(float value);
284
285
286  public: 
287     virtual ~SgAsmSingleFloatValueExpression();
288
289
290  public: 
291     SgAsmSingleFloatValueExpression(float value = 0.0F); 
292
293  protected:
294     // Start of memberFunctionString
295     float p_value;
296 };
297
298
299 class SgAsmDoubleFloatValueExpression : public SgAsmValueExpression
300 {
301  public:
302         virtual SgAsmType* get_type();
303
304     /*! \brief returns a string representing the class name */
305     virtual std::string class_name() const;
306
307     /*! \brief returns new style SageIII enum values */
308     virtual VariantT variantT() const; // MS: new variant used in tree traversal
309
310     /*! \brief static variant value */
311     static const VariantT static_variant = V_SgAsmDoubleFloatValueExpression;
312
313     /* the generated cast function */
314     /*! \brief Casts pointer from base class to derived class */
315     friend       SgAsmDoubleFloatValueExpression* isSgAsmDoubleFloatValueExpression(       SgNode * s );
316     /*! \brief Casts pointer from base class to derived class (for const pointers) */
317     friend const SgAsmDoubleFloatValueExpression* isSgAsmDoubleFloatValueExpression( const SgNode * s );
318  public: 
319     double get_value() const;
320     void set_value(double value);
321
322
323  public: 
324     virtual ~SgAsmDoubleFloatValueExpression();
325
326
327  public: 
328     SgAsmDoubleFloatValueExpression(double value = 0.0); 
329
330  protected:
331     // Start of memberFunctionString
332     double p_value;
333 };
334
335 class SgAsmType;
336
337 class SgAsmVectorValueExpression : public SgAsmValueExpression
338 {
339  public:
340         virtual SgAsmType* get_type();
341
342     /*! \brief returns a string representing the class name */
343     virtual std::string class_name() const;
344
345     /*! \brief returns new style SageIII enum values */
346     virtual VariantT variantT() const; // MS: new variant used in tree traversal
347
348     /*! \brief static variant value */
349     static const VariantT static_variant = V_SgAsmVectorValueExpression;
350
351     /* the generated cast function */
352     /*! \brief Casts pointer from base class to derived class */
353     friend       SgAsmVectorValueExpression* isSgAsmVectorValueExpression(       SgNode * s );
354     /*! \brief Casts pointer from base class to derived class (for const pointers) */
355     friend const SgAsmVectorValueExpression* isSgAsmVectorValueExpression( const SgNode * s );
356
357  public: 
358     unsigned int get_size() const;
359     void set_size(unsigned int size);
360
361  public: 
362     SgAsmType* get_type() const;
363     void set_type(SgAsmType* type);
364
365
366  public: 
367     virtual ~SgAsmVectorValueExpression();
368
369
370  public: 
371     SgAsmVectorValueExpression(); 
372
373  protected:
374     // Start of memberFunctionString
375     unsigned int p_size;
376           
377     // End of memberFunctionString
378     // Start of memberFunctionString
379     SgAsmType* p_type;
380           
381     // End of memberFunctionString
382 };
383
384 class SgAsmBinaryExpression : public SgAsmExpression
385 {
386  public:
387
388         virtual SgAsmType* get_type();
389
390     /*! \brief returns a string representing the class name */
391     virtual std::string class_name() const;
392
393     /*! \brief returns new style SageIII enum values */
394     virtual VariantT variantT() const; // MS: new variant used in tree traversal
395
396     /*! \brief static variant value */
397     static const VariantT static_variant = V_SgAsmBinaryExpression;
398
399     /* the generated cast function */
400     /*! \brief Casts pointer from base class to derived class */
401     friend       SgAsmBinaryExpression* isSgAsmBinaryExpression(       SgNode * s );
402     /*! \brief Casts pointer from base class to derived class (for const pointers) */
403     friend const SgAsmBinaryExpression* isSgAsmBinaryExpression( const SgNode * s );
404
405  public: 
406     SgAsmExpression* get_lhs() const;
407     void set_lhs(SgAsmExpression* lhs);
408
409  public: 
410     SgAsmExpression* get_rhs() const;
411     void set_rhs(SgAsmExpression* rhs);
412
413
414  public: 
415     virtual ~SgAsmBinaryExpression();
416
417
418  public: 
419     SgAsmBinaryExpression(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
420
421  protected:
422     // Start of memberFunctionString
423     SgAsmExpression* p_lhs;
424           
425     // End of memberFunctionString
426     // Start of memberFunctionString
427     SgAsmExpression* p_rhs;
428           
429     // End of memberFunctionString
430
431
432 };
433
434 class SgAsmBinaryAdd : public SgAsmBinaryExpression
435 {
436  public:
437
438
439     virtual SgAsmType* get_type();
440
441     /*! \brief returns a string representing the class name */
442     virtual std::string class_name() const;
443
444     /*! \brief returns new style SageIII enum values */
445     virtual VariantT variantT() const; // MS: new variant used in tree traversal
446
447     /*! \brief static variant value */
448     static const VariantT static_variant = V_SgAsmBinaryAdd;
449
450     /* the generated cast function */
451     /*! \brief Casts pointer from base class to derived class */
452     friend       SgAsmBinaryAdd* isSgAsmBinaryAdd(       SgNode * s );
453     /*! \brief Casts pointer from base class to derived class (for const pointers) */
454     friend const SgAsmBinaryAdd* isSgAsmBinaryAdd( const SgNode * s );
455
456  public: 
457     virtual ~SgAsmBinaryAdd();
458
459
460  public: 
461     SgAsmBinaryAdd(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
462
463  protected:
464 };
465
466 class SgAsmBinarySubtract : public SgAsmBinaryExpression
467 {
468  public:
469     virtual SgAsmType* get_type();
470
471     /*! \brief returns a string representing the class name */
472     virtual std::string class_name() const;
473
474     /*! \brief returns new style SageIII enum values */
475     virtual VariantT variantT() const; // MS: new variant used in tree traversal
476
477     /*! \brief static variant value */
478     static const VariantT static_variant = V_SgAsmBinarySubtract;
479
480     /* the generated cast function */
481     /*! \brief Casts pointer from base class to derived class */
482     friend       SgAsmBinarySubtract* isSgAsmBinarySubtract(       SgNode * s );
483     /*! \brief Casts pointer from base class to derived class (for const pointers) */
484     friend const SgAsmBinarySubtract* isSgAsmBinarySubtract( const SgNode * s );
485  public: 
486     virtual ~SgAsmBinarySubtract();
487
488
489  public: 
490     SgAsmBinarySubtract(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
491
492  protected:
493
494
495
496
497 };
498
499 // Class Definition for SgAsmBinaryMultiply
500 class SgAsmBinaryMultiply : public SgAsmBinaryExpression
501 {
502  public:
503     virtual SgAsmType* get_type();
504
505     /*! \brief returns a string representing the class name */
506     virtual std::string class_name() const;
507
508     /*! \brief returns new style SageIII enum values */
509     virtual VariantT variantT() const; // MS: new variant used in tree traversal
510
511     /*! \brief static variant value */
512     static const VariantT static_variant = V_SgAsmBinaryMultiply;
513
514     /* the generated cast function */
515     /*! \brief Casts pointer from base class to derived class */
516     friend       SgAsmBinaryMultiply* isSgAsmBinaryMultiply(       SgNode * s );
517     /*! \brief Casts pointer from base class to derived class (for const pointers) */
518     friend const SgAsmBinaryMultiply* isSgAsmBinaryMultiply( const SgNode * s );
519
520  public: 
521     virtual ~SgAsmBinaryMultiply();
522
523
524  public: 
525     SgAsmBinaryMultiply(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
526 };
527
528 class SgAsmBinaryDivide : public SgAsmBinaryExpression
529 {
530  public:
531     virtual SgAsmType* get_type();
532
533     /*! \brief returns a string representing the class name */
534     virtual std::string class_name() const;
535
536     /*! \brief returns new style SageIII enum values */
537     virtual VariantT variantT() const; // MS: new variant used in tree traversal
538
539     /*! \brief static variant value */
540     static const VariantT static_variant = V_SgAsmBinaryDivide;
541
542     /* the generated cast function */
543     /*! \brief Casts pointer from base class to derived class */
544     friend       SgAsmBinaryDivide* isSgAsmBinaryDivide(       SgNode * s );
545     /*! \brief Casts pointer from base class to derived class (for const pointers) */
546     friend const SgAsmBinaryDivide* isSgAsmBinaryDivide( const SgNode * s );
547
548  public: 
549     virtual ~SgAsmBinaryDivide();
550
551
552  public: 
553     SgAsmBinaryDivide(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
554
555  protected:
556
557
558 };
559
560 // Class Definition for SgAsmBinaryMod
561 class SgAsmBinaryMod : public SgAsmBinaryExpression
562 {
563  public:    
564     virtual SgAsmType* get_type();
565     /*! \brief returns a string representing the class name */
566     virtual std::string class_name() const;
567
568     /*! \brief returns new style SageIII enum values */
569     virtual VariantT variantT() const; // MS: new variant used in tree traversal
570
571     /*! \brief static variant value */
572     static const VariantT static_variant = V_SgAsmBinaryMod;
573
574     /* the generated cast function */
575     /*! \brief Casts pointer from base class to derived class */
576     friend       SgAsmBinaryMod* isSgAsmBinaryMod(       SgNode * s );
577     /*! \brief Casts pointer from base class to derived class (for const pointers) */
578     friend const SgAsmBinaryMod* isSgAsmBinaryMod( const SgNode * s );
579
580  public: 
581     virtual ~SgAsmBinaryMod();
582
583
584  public: 
585     SgAsmBinaryMod(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
586 };
587
588 class SgAsmBinaryAddPreupdate : public SgAsmBinaryExpression
589 {
590  public:
591     virtual SgAsmType* get_type();
592
593     /*! \brief returns a string representing the class name */
594     virtual std::string class_name() const;
595
596     /*! \brief returns new style SageIII enum values */
597     virtual VariantT variantT() const; // MS: new variant used in tree traversal
598
599     /*! \brief static variant value */
600     static const VariantT static_variant = V_SgAsmBinaryAddPreupdate;
601
602     /* the generated cast function */
603     /*! \brief Casts pointer from base class to derived class */
604     friend       SgAsmBinaryAddPreupdate* isSgAsmBinaryAddPreupdate(       SgNode * s );
605     /*! \brief Casts pointer from base class to derived class (for const pointers) */
606     friend const SgAsmBinaryAddPreupdate* isSgAsmBinaryAddPreupdate( const SgNode * s );
607
608  public: 
609     virtual ~SgAsmBinaryAddPreupdate();
610
611
612  public: 
613     SgAsmBinaryAddPreupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
614
615
616 };
617
618 class SgAsmBinarySubtractPreupdate : public SgAsmBinaryExpression
619 {
620  public:
621     virtual SgAsmType* get_type();
622
623     /*! \brief returns a string representing the class name */
624     virtual std::string class_name() const;
625
626     /*! \brief returns new style SageIII enum values */
627     virtual VariantT variantT() const; // MS: new variant used in tree traversal
628
629     /*! \brief static variant value */
630     static const VariantT static_variant = V_SgAsmBinarySubtractPreupdate;
631
632     /* the generated cast function */
633     /*! \brief Casts pointer from base class to derived class */
634     friend       SgAsmBinarySubtractPreupdate* isSgAsmBinarySubtractPreupdate(       SgNode * s );
635     /*! \brief Casts pointer from base class to derived class (for const pointers) */
636     friend const SgAsmBinarySubtractPreupdate* isSgAsmBinarySubtractPreupdate( const SgNode * s );
637
638
639  public: 
640     virtual ~SgAsmBinarySubtractPreupdate();
641
642
643  public: 
644     SgAsmBinarySubtractPreupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
645
646 };
647
648 class SgAsmBinaryAddPostupdate : public SgAsmBinaryExpression
649 {
650  public:
651
652     virtual SgAsmType* get_type();
653     /*! \brief returns a string representing the class name */
654     virtual std::string class_name() const;
655
656     /*! \brief returns new style SageIII enum values */
657     virtual VariantT variantT() const; // MS: new variant used in tree traversal
658
659     /*! \brief static variant value */
660     static const VariantT static_variant = V_SgAsmBinaryAddPostupdate;
661
662     /* the generated cast function */
663     /*! \brief Casts pointer from base class to derived class */
664     friend       SgAsmBinaryAddPostupdate* isSgAsmBinaryAddPostupdate(       SgNode * s );
665     /*! \brief Casts pointer from base class to derived class (for const pointers) */
666     friend const SgAsmBinaryAddPostupdate* isSgAsmBinaryAddPostupdate( const SgNode * s );
667
668  public: 
669     virtual ~SgAsmBinaryAddPostupdate();
670
671
672  public: 
673     SgAsmBinaryAddPostupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
674
675
676 };
677
678 class SgAsmBinarySubtractPostupdate : public SgAsmBinaryExpression
679 {
680  public:
681
682     virtual SgAsmType* get_type();
683     /*! \brief returns a string representing the class name */
684     virtual std::string class_name() const;
685
686     /*! \brief returns new style SageIII enum values */
687     virtual VariantT variantT() const; // MS: new variant used in tree traversal
688
689     /*! \brief static variant value */
690     static const VariantT static_variant = V_SgAsmBinarySubtractPostupdate;
691
692     /* the generated cast function */
693     /*! \brief Casts pointer from base class to derived class */
694     friend       SgAsmBinarySubtractPostupdate* isSgAsmBinarySubtractPostupdate(       SgNode * s );
695     /*! \brief Casts pointer from base class to derived class (for const pointers) */
696     friend const SgAsmBinarySubtractPostupdate* isSgAsmBinarySubtractPostupdate( const SgNode * s );
697
698  public: 
699     virtual ~SgAsmBinarySubtractPostupdate();
700
701
702  public: 
703     SgAsmBinarySubtractPostupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
704
705 };
706
707 class SgAsmBinaryLsl : public SgAsmBinaryExpression
708 {
709  public:
710     virtual SgAsmType* get_type();
711     /*! \brief returns a string representing the class name */
712     virtual std::string class_name() const;
713
714     /*! \brief returns new style SageIII enum values */
715     virtual VariantT variantT() const; // MS: new variant used in tree traversal
716
717     /*! \brief static variant value */
718     static const VariantT static_variant = V_SgAsmBinaryLsl;
719
720     /* the generated cast function */
721     /*! \brief Casts pointer from base class to derived class */
722     friend       SgAsmBinaryLsl* isSgAsmBinaryLsl(       SgNode * s );
723     /*! \brief Casts pointer from base class to derived class (for const pointers) */
724     friend const SgAsmBinaryLsl* isSgAsmBinaryLsl( const SgNode * s );
725
726
727
728  public: 
729     virtual ~SgAsmBinaryLsl();
730
731
732  public: 
733     SgAsmBinaryLsl(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
734
735 };
736
737 class SgAsmBinaryLsr : public SgAsmBinaryExpression
738 {
739  public:
740     virtual SgAsmType* get_type();
741
742
743     /*! \brief returns a string representing the class name */
744     virtual std::string class_name() const;
745
746     /*! \brief returns new style SageIII enum values */
747     virtual VariantT variantT() const; // MS: new variant used in tree traversal
748
749     /*! \brief static variant value */
750     static const VariantT static_variant = V_SgAsmBinaryLsr;
751
752     /* the generated cast function */
753     /*! \brief Casts pointer from base class to derived class */
754     friend       SgAsmBinaryLsr* isSgAsmBinaryLsr(       SgNode * s );
755     /*! \brief Casts pointer from base class to derived class (for const pointers) */
756     friend const SgAsmBinaryLsr* isSgAsmBinaryLsr( const SgNode * s );
757
758  public: 
759     virtual ~SgAsmBinaryLsr();
760
761
762  public: 
763     SgAsmBinaryLsr(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
764
765 };
766
767 class SgAsmBinaryAsr : public SgAsmBinaryExpression
768 {
769  public:
770     virtual SgAsmType* get_type();
771
772
773     /*! \brief returns a string representing the class name */
774     virtual std::string class_name() const;
775
776     /*! \brief returns new style SageIII enum values */
777     virtual VariantT variantT() const; // MS: new variant used in tree traversal
778
779     /*! \brief static variant value */
780     static const VariantT static_variant = V_SgAsmBinaryAsr;
781
782     /* the generated cast function */
783     /*! \brief Casts pointer from base class to derived class */
784     friend       SgAsmBinaryAsr* isSgAsmBinaryAsr(       SgNode * s );
785     /*! \brief Casts pointer from base class to derived class (for const pointers) */
786     friend const SgAsmBinaryAsr* isSgAsmBinaryAsr( const SgNode * s );
787
788  public: 
789     virtual ~SgAsmBinaryAsr();
790
791
792  public: 
793     SgAsmBinaryAsr(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
794
795 };
796
797 class SgAsmBinaryRor : public SgAsmBinaryExpression
798 {
799  public:      
800     virtual SgAsmType* get_type();
801     /*! \brief returns a string representing the class name */
802     virtual std::string class_name() const;
803
804     /*! \brief returns new style SageIII enum values */
805     virtual VariantT variantT() const; // MS: new variant used in tree traversal
806
807     /*! \brief static variant value */
808     static const VariantT static_variant = V_SgAsmBinaryRor;
809
810     /* the generated cast function */
811     /*! \brief Casts pointer from base class to derived class */
812     friend       SgAsmBinaryRor* isSgAsmBinaryRor(       SgNode * s );
813     /*! \brief Casts pointer from base class to derived class (for const pointers) */
814     friend const SgAsmBinaryRor* isSgAsmBinaryRor( const SgNode * s );
815
816
817  public: 
818     virtual ~SgAsmBinaryRor();
819
820
821  public: 
822     SgAsmBinaryRor(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
823
824  
825 };
826
827 class SgAsmUnaryExpression : public SgAsmExpression
828 {
829  public:
830     virtual SgAsmType* get_type();
831     /*! \brief returns a string representing the class name */
832     virtual std::string class_name() const;
833
834     /*! \brief returns new style SageIII enum values */
835     virtual VariantT variantT() const; // MS: new variant used in tree traversal
836
837     /*! \brief static variant value */
838     static const VariantT static_variant = V_SgAsmUnaryExpression;
839
840     /* the generated cast function */
841     /*! \brief Casts pointer from base class to derived class */
842     friend       SgAsmUnaryExpression* isSgAsmUnaryExpression(       SgNode * s );
843     /*! \brief Casts pointer from base class to derived class (for const pointers) */
844     friend const SgAsmUnaryExpression* isSgAsmUnaryExpression( const SgNode * s );
845
846  public: 
847     SgAsmExpression* get_operand() const;
848     void set_operand(SgAsmExpression* operand);
849
850
851  public: 
852     virtual ~SgAsmUnaryExpression();
853
854
855  public: 
856     SgAsmUnaryExpression(SgAsmExpression* operand = NULL); 
857
858  protected:
859     // Start of memberFunctionString
860     SgAsmExpression* p_operand;
861           
862     // End of memberFunctionString
863
864
865 };
866
867 class SgAsmUnaryPlus : public SgAsmUnaryExpression
868 {
869  public:
870     virtual SgAsmType* get_type();
871
872     /*! \brief returns a string representing the class name */
873     virtual std::string class_name() const;
874
875     /*! \brief returns new style SageIII enum values */
876     virtual VariantT variantT() const; // MS: new variant used in tree traversal
877
878     /*! \brief static variant value */
879     static const VariantT static_variant = V_SgAsmUnaryPlus;
880
881     /* the generated cast function */
882     /*! \brief Casts pointer from base class to derived class */
883     friend       SgAsmUnaryPlus* isSgAsmUnaryPlus(       SgNode * s );
884     /*! \brief Casts pointer from base class to derived class (for const pointers) */
885     friend const SgAsmUnaryPlus* isSgAsmUnaryPlus( const SgNode * s );
886
887  public: 
888     virtual ~SgAsmUnaryPlus();
889
890
891  public: 
892     SgAsmUnaryPlus(SgAsmExpression* operand = NULL); 
893
894  protected:
895
896
897 };
898
899 class SgAsmUnaryMinus : public SgAsmUnaryExpression
900 {
901  public:
902     virtual SgAsmType* get_type();
903
904     /*! \brief returns a string representing the class name */
905     virtual std::string class_name() const;
906
907     /*! \brief returns new style SageIII enum values */
908     virtual VariantT variantT() const; // MS: new variant used in tree traversal
909
910     /*! \brief static variant value */
911     static const VariantT static_variant = V_SgAsmUnaryMinus;
912
913     /* the generated cast function */
914     /*! \brief Casts pointer from base class to derived class */
915     friend       SgAsmUnaryMinus* isSgAsmUnaryMinus(       SgNode * s );
916     /*! \brief Casts pointer from base class to derived class (for const pointers) */
917     friend const SgAsmUnaryMinus* isSgAsmUnaryMinus( const SgNode * s );
918
919
920  public: 
921     virtual ~SgAsmUnaryMinus();
922
923
924  public: 
925     SgAsmUnaryMinus(SgAsmExpression* operand = NULL); 
926
927  protected:
928
929
930 };
931
932 // Class Definition for SgAsmUnaryRrx
933 class SgAsmUnaryRrx : public SgAsmUnaryExpression
934 {
935  public:
936
937     virtual SgAsmType* get_type();
938
939     /*! \brief returns a string representing the class name */
940     virtual std::string class_name() const;
941
942     /*! \brief returns new style SageIII enum values */
943     virtual VariantT variantT() const; // MS: new variant used in tree traversal
944
945     /*! \brief static variant value */
946     static const VariantT static_variant = V_SgAsmUnaryRrx;
947
948     /* the generated cast function */
949     /*! \brief Casts pointer from base class to derived class */
950     friend       SgAsmUnaryRrx* isSgAsmUnaryRrx(       SgNode * s );
951     /*! \brief Casts pointer from base class to derived class (for const pointers) */
952     friend const SgAsmUnaryRrx* isSgAsmUnaryRrx( const SgNode * s );
953
954  public: 
955     virtual ~SgAsmUnaryRrx();
956
957
958  public: 
959     SgAsmUnaryRrx(SgAsmExpression* operand = NULL); 
960
961  protected:
962
963
964 };
965
966 // Class Definition for SgAsmMemoryReferenceExpression
967 class SgAsmMemoryReferenceExpression : public SgAsmExpression
968 {
969  public:
970     virtual SgAsmType* get_type();
971
972     /*! \brief returns a string representing the class name */
973     virtual std::string class_name() const;
974
975     /*! \brief returns new style SageIII enum values */
976     virtual VariantT variantT() const; // MS: new variant used in tree traversal
977
978     /*! \brief static variant value */
979     static const VariantT static_variant = V_SgAsmMemoryReferenceExpression;
980
981     /* the generated cast function */
982     /*! \brief Casts pointer from base class to derived class */
983     friend       SgAsmMemoryReferenceExpression* isSgAsmMemoryReferenceExpression(       SgNode * s );
984     /*! \brief Casts pointer from base class to derived class (for const pointers) */
985     friend const SgAsmMemoryReferenceExpression* isSgAsmMemoryReferenceExpression( const SgNode * s );
986
987  public: 
988     SgAsmExpression* get_address() const;
989     void set_address(SgAsmExpression* address);
990
991  public: 
992     SgAsmExpression* get_segment() const;
993     void set_segment(SgAsmExpression* segment);
994
995  public: 
996     SgAsmType* get_type() const;
997     void set_type(SgAsmType* type);
998
999
1000  public: 
1001     virtual ~SgAsmMemoryReferenceExpression();
1002
1003
1004  public: 
1005     SgAsmMemoryReferenceExpression(SgAsmExpression* address = NULL, SgAsmExpression* segment = NULL); 
1006
1007  protected:
1008     // Start of memberFunctionString
1009     SgAsmExpression* p_address;
1010           
1011     // End of memberFunctionString
1012     // Start of memberFunctionString
1013     SgAsmExpression* p_segment;
1014           
1015     // End of memberFunctionString
1016     // Start of memberFunctionString
1017     SgAsmType* p_type;
1018           
1019     // End of memberFunctionString
1020
1021
1022 };
1023
1024 // Class Definition for SgAsmRegisterReferenceExpression
1025 class SgAsmRegisterReferenceExpression : public SgAsmExpression
1026 {
1027  public:
1028     virtual SgAsmType* get_type();
1029
1030
1031     /*! \brief returns a string representing the class name */
1032     virtual std::string class_name() const;
1033
1034     /*! \brief returns new style SageIII enum values */
1035     virtual VariantT variantT() const; // MS: new variant used in tree traversal
1036
1037     /*! \brief static variant value */
1038     static const VariantT static_variant = V_SgAsmRegisterReferenceExpression;
1039
1040     /* the generated cast function */
1041     /*! \brief Casts pointer from base class to derived class */
1042     friend       SgAsmRegisterReferenceExpression* isSgAsmRegisterReferenceExpression(       SgNode * s );
1043     /*! \brief Casts pointer from base class to derived class (for const pointers) */
1044     friend const SgAsmRegisterReferenceExpression* isSgAsmRegisterReferenceExpression( const SgNode * s );
1045
1046  public: 
1047     virtual void set_type(SgAsmType* type);
1048
1049
1050  public: 
1051     virtual ~SgAsmRegisterReferenceExpression();
1052
1053
1054  public: 
1055     SgAsmRegisterReferenceExpression(); 
1056
1057  protected:
1058     // Start of memberFunctionString
1059     SgAsmType* p_type;
1060           
1061     // End of memberFunctionString
1062
1063
1064 };
1065
1066 class SgAsmx86RegisterReferenceExpression : public SgAsmRegisterReferenceExpression
1067 {
1068  public:
1069
1070
1071     //! Get a unique identifier for this particular register
1072     std::pair<X86RegisterClass, int> get_identifier() const;
1073
1074     /*! \brief returns a string representing the class name */
1075     virtual std::string class_name() const;
1076
1077     /*! \brief returns new style SageIII enum values */
1078     virtual VariantT variantT() const; // MS: new variant used in tree traversal
1079
1080     /*! \brief static variant value */
1081     static const VariantT static_variant = V_SgAsmx86RegisterReferenceExpression;
1082
1083     /* the generated cast function */
1084     /*! \brief Casts pointer from base class to derived class */
1085     friend       SgAsmx86RegisterReferenceExpression* isSgAsmx86RegisterReferenceExpression(       SgNode * s );
1086     /*! \brief Casts pointer from base class to derived class (for const pointers) */
1087     friend const SgAsmx86RegisterReferenceExpression* isSgAsmx86RegisterReferenceExpression( const SgNode * s );
1088
1089  public: 
1090     X86RegisterClass get_register_class() const;
1091     void set_register_class(X86RegisterClass register_class);
1092
1093  public: 
1094     int get_register_number() const;
1095     void set_register_number(int register_number);
1096
1097  public: 
1098     X86PositionInRegister get_position_in_register() const;
1099     void set_position_in_register(X86PositionInRegister position_in_register);
1100
1101
1102  public: 
1103     virtual ~SgAsmx86RegisterReferenceExpression();
1104
1105
1106  public: 
1107     SgAsmx86RegisterReferenceExpression(X86RegisterClass register_class = x86_regclass_unknown, int register_number = 0, X86PositionInRegister position_in_register = x86_regpos_unknown); 
1108
1109  protected:
1110     // Start of memberFunctionString
1111     X86RegisterClass p_register_class;
1112           
1113     // End of memberFunctionString
1114     // Start of memberFunctionString
1115     int p_register_number;
1116           
1117     // End of memberFunctionString
1118     // Start of memberFunctionString
1119     X86PositionInRegister p_position_in_register;
1120           
1121     // End of memberFunctionString
1122 };
1123
1124 // Class Definition for SgAsmPowerpcRegisterReferenceExpression
1125 class SgAsmPowerpcRegisterReferenceExpression : public SgAsmRegisterReferenceExpression
1126 {
1127     public:
1128         enum powerpc_register_enum { // The exact numbers here are important
1129     undefined_powerpc_register = 0, /*!< unknown (error or unitialized value) */
1130     reg0 = 1,
1131     reg1 = 2,
1132     reg2 = 3,
1133     reg3 = 4,
1134     reg4 = 5,
1135     reg5 = 6,
1136     reg6 = 7,
1137     reg7 = 8,
1138     last_powerpc_register
1139         };
1140
1141     public:
1142
1143         /*! \brief returns a string representing the class name */
1144         virtual std::string class_name() const { return "SgAsmPowerpcRegisterReferenceExpression"; }
1145
1146         /*! \brief returns new style SageIII enum values */
1147         virtual VariantT variantT() const { return static_variant; } 
1148
1149         /*! \brief static variant value */
1150         static const VariantT static_variant = V_SgAsmPowerpcRegisterReferenceExpression;
1151
1152         /* the generated cast function */
1153         /*! \brief Casts pointer from base class to derived class */
1154         friend       SgAsmPowerpcRegisterReferenceExpression* isSgAsmPowerpcRegisterReferenceExpression(       SgNode * s );
1155         /*! \brief Casts pointer from base class to derived class (for const pointers) */
1156         friend const SgAsmPowerpcRegisterReferenceExpression* isSgAsmPowerpcRegisterReferenceExpression( const SgNode * s );
1157
1158     public:
1159         PowerpcRegisterClass get_register_class() const;
1160         void set_register_class(PowerpcRegisterClass register_class);
1161         int get_register_number() const;
1162         void set_register_number(int register_number);
1163         PowerpcConditionRegisterAccessGranularity get_conditionRegisterGranularity() const;
1164         void set_conditionRegisterGranularity(PowerpcConditionRegisterAccessGranularity conditionRegisterGranularity);
1165         virtual ~SgAsmPowerpcRegisterReferenceExpression();
1166         SgAsmPowerpcRegisterReferenceExpression(PowerpcRegisterClass register_class = powerpc_regclass_unknown, int
1167                 register_number = 0, PowerpcConditionRegisterAccessGranularity conditionRegisterGranularity =
1168                         powerpc_condreggranularity_whole);
1169
1170     protected:
1171         PowerpcRegisterClass p_register_class;
1172         int p_register_number;
1173         PowerpcConditionRegisterAccessGranularity p_conditionRegisterGranularity;
1174 };
1175
1176 uint64_t getAsmSignedConstant(SgAsmValueExpression *e);
1177
1178
1179 #endif