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