001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *   https://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing,
013 * software distributed under the License is distributed on an
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015 * KIND, either express or implied.  See the License for the
016 * specific language governing permissions and limitations
017 * under the License.
018 */
019package org.apache.bcel.generic;
020
021/**
022 * Interface implementing the Visitor pattern programming style. I.e., a class that implements this interface can handle
023 * all types of instructions with the properly typed methods just by calling the accept() method.
024 */
025public interface Visitor {
026
027    /**
028     * Visits an AALOAD instruction.
029     *
030     * @param obj the instruction.
031     */
032    void visitAALOAD(AALOAD obj);
033
034    /**
035     * Visits an AASTORE instruction.
036     *
037     * @param obj the instruction.
038     */
039    void visitAASTORE(AASTORE obj);
040
041    /**
042     * Visits an ACONST_NULL instruction.
043     *
044     * @param obj the instruction.
045     */
046    void visitACONST_NULL(ACONST_NULL obj);
047
048    /**
049     * Visits an AllocationInstruction.
050     *
051     * @param obj the instruction.
052     */
053    void visitAllocationInstruction(AllocationInstruction obj);
054
055    /**
056     * Visits an ALOAD instruction.
057     *
058     * @param obj the instruction.
059     */
060    void visitALOAD(ALOAD obj);
061
062    /**
063     * Visits an ANEWARRAY instruction.
064     *
065     * @param obj the instruction.
066     */
067    void visitANEWARRAY(ANEWARRAY obj);
068
069    /**
070     * Visits an ARETURN instruction.
071     *
072     * @param obj the instruction.
073     */
074    void visitARETURN(ARETURN obj);
075
076    /**
077     * Visits an ArithmeticInstruction.
078     *
079     * @param obj the instruction.
080     */
081    void visitArithmeticInstruction(ArithmeticInstruction obj);
082
083    /**
084     * Visits an ArrayInstruction.
085     *
086     * @param obj the instruction.
087     */
088    void visitArrayInstruction(ArrayInstruction obj);
089
090    /**
091     * Visits an ARRAYLENGTH instruction.
092     *
093     * @param obj the instruction.
094     */
095    void visitARRAYLENGTH(ARRAYLENGTH obj);
096
097    /**
098     * Visits an ASTORE instruction.
099     *
100     * @param obj the instruction.
101     */
102    void visitASTORE(ASTORE obj);
103
104    /**
105     * Visits an ATHROW instruction.
106     *
107     * @param obj the instruction.
108     */
109    void visitATHROW(ATHROW obj);
110
111    /**
112     * Visits a BALOAD instruction.
113     *
114     * @param obj the instruction.
115     */
116    void visitBALOAD(BALOAD obj);
117
118    /**
119     * Visits a BASTORE instruction.
120     *
121     * @param obj the instruction.
122     */
123    void visitBASTORE(BASTORE obj);
124
125    /**
126     * Visits a BIPUSH instruction.
127     *
128     * @param obj the instruction.
129     */
130    void visitBIPUSH(BIPUSH obj);
131
132    /**
133     * Visits a BranchInstruction.
134     *
135     * @param obj the instruction.
136     */
137    void visitBranchInstruction(BranchInstruction obj);
138
139    /**
140     * Visits a BREAKPOINT instruction.
141     *
142     * @param obj the instruction.
143     */
144    void visitBREAKPOINT(BREAKPOINT obj);
145
146    /**
147     * Visits a CALOAD instruction.
148     *
149     * @param obj the instruction.
150     */
151    void visitCALOAD(CALOAD obj);
152
153    /**
154     * Visits a CASTORE instruction.
155     *
156     * @param obj the instruction.
157     */
158    void visitCASTORE(CASTORE obj);
159
160    /**
161     * Visits a CHECKCAST instruction.
162     *
163     * @param obj the instruction.
164     */
165    void visitCHECKCAST(CHECKCAST obj);
166
167    /**
168     * Visits a ConstantPushInstruction.
169     *
170     * @param obj the instruction.
171     */
172    void visitConstantPushInstruction(ConstantPushInstruction obj);
173
174    /**
175     * Visits a ConversionInstruction.
176     *
177     * @param obj the instruction.
178     */
179    void visitConversionInstruction(ConversionInstruction obj);
180
181    /**
182     * Visits a CPInstruction.
183     *
184     * @param obj the instruction.
185     */
186    void visitCPInstruction(CPInstruction obj);
187
188    /**
189     * Visits a D2F instruction.
190     *
191     * @param obj the instruction.
192     */
193    void visitD2F(D2F obj);
194
195    /**
196     * Visits a D2I instruction.
197     *
198     * @param obj the instruction.
199     */
200    void visitD2I(D2I obj);
201
202    /**
203     * Visits a D2L instruction.
204     *
205     * @param obj the instruction.
206     */
207    void visitD2L(D2L obj);
208
209    /**
210     * Visits a DADD instruction.
211     *
212     * @param obj the instruction.
213     */
214    void visitDADD(DADD obj);
215
216    /**
217     * Visits a DALOAD instruction.
218     *
219     * @param obj the instruction.
220     */
221    void visitDALOAD(DALOAD obj);
222
223    /**
224     * Visits a DASTORE instruction.
225     *
226     * @param obj the instruction.
227     */
228    void visitDASTORE(DASTORE obj);
229
230    /**
231     * Visits a DCMPG instruction.
232     *
233     * @param obj the instruction.
234     */
235    void visitDCMPG(DCMPG obj);
236
237    /**
238     * Visits a DCMPL instruction.
239     *
240     * @param obj the instruction.
241     */
242    void visitDCMPL(DCMPL obj);
243
244    /**
245     * Visits a DCONST instruction.
246     *
247     * @param obj the instruction.
248     */
249    void visitDCONST(DCONST obj);
250
251    /**
252     * Visits a DDIV instruction.
253     *
254     * @param obj the instruction.
255     */
256    void visitDDIV(DDIV obj);
257
258    /**
259     * Visits a DLOAD instruction.
260     *
261     * @param obj the instruction.
262     */
263    void visitDLOAD(DLOAD obj);
264
265    /**
266     * Visits a DMUL instruction.
267     *
268     * @param obj the instruction.
269     */
270    void visitDMUL(DMUL obj);
271
272    /**
273     * Visits a DNEG instruction.
274     *
275     * @param obj the instruction.
276     */
277    void visitDNEG(DNEG obj);
278
279    /**
280     * Visits a DREM instruction.
281     *
282     * @param obj the instruction.
283     */
284    void visitDREM(DREM obj);
285
286    /**
287     * Visits a DRETURN instruction.
288     *
289     * @param obj the instruction.
290     */
291    void visitDRETURN(DRETURN obj);
292
293    /**
294     * Visits a DSTORE instruction.
295     *
296     * @param obj the instruction.
297     */
298    void visitDSTORE(DSTORE obj);
299
300    /**
301     * Visits a DSUB instruction.
302     *
303     * @param obj the instruction.
304     */
305    void visitDSUB(DSUB obj);
306
307    /**
308     * Visits a DUP instruction.
309     *
310     * @param obj the instruction.
311     */
312    void visitDUP(DUP obj);
313
314    /**
315     * Visits a DUP_X1 instruction.
316     *
317     * @param obj the instruction.
318     */
319    void visitDUP_X1(DUP_X1 obj);
320
321    /**
322     * Visits a DUP_X2 instruction.
323     *
324     * @param obj the instruction.
325     */
326    void visitDUP_X2(DUP_X2 obj);
327
328    /**
329     * Visits a DUP2 instruction.
330     *
331     * @param obj the instruction.
332     */
333    void visitDUP2(DUP2 obj);
334
335    /**
336     * Visits a DUP2_X1 instruction.
337     *
338     * @param obj the instruction.
339     */
340    void visitDUP2_X1(DUP2_X1 obj);
341
342    /**
343     * Visits a DUP2_X2 instruction.
344     *
345     * @param obj the instruction.
346     */
347    void visitDUP2_X2(DUP2_X2 obj);
348
349    /**
350     * Visits an ExceptionThrower.
351     *
352     * @param obj the instruction.
353     */
354    void visitExceptionThrower(ExceptionThrower obj);
355
356    /**
357     * Visits an F2D instruction.
358     *
359     * @param obj the instruction.
360     */
361    void visitF2D(F2D obj);
362
363    /**
364     * Visits an F2I instruction.
365     *
366     * @param obj the instruction.
367     */
368    void visitF2I(F2I obj);
369
370    /**
371     * Visits an F2L instruction.
372     *
373     * @param obj the instruction.
374     */
375    void visitF2L(F2L obj);
376
377    /**
378     * Visits an FADD instruction.
379     *
380     * @param obj the instruction.
381     */
382    void visitFADD(FADD obj);
383
384    /**
385     * Visits an FALOAD instruction.
386     *
387     * @param obj the instruction.
388     */
389    void visitFALOAD(FALOAD obj);
390
391    /**
392     * Visits an FASTORE instruction.
393     *
394     * @param obj the instruction.
395     */
396    void visitFASTORE(FASTORE obj);
397
398    /**
399     * Visits an FCMPG instruction.
400     *
401     * @param obj the instruction.
402     */
403    void visitFCMPG(FCMPG obj);
404
405    /**
406     * Visits an FCMPL instruction.
407     *
408     * @param obj the instruction.
409     */
410    void visitFCMPL(FCMPL obj);
411
412    /**
413     * Visits an FCONST instruction.
414     *
415     * @param obj the instruction.
416     */
417    void visitFCONST(FCONST obj);
418
419    /**
420     * Visits an FDIV instruction.
421     *
422     * @param obj the instruction.
423     */
424    void visitFDIV(FDIV obj);
425
426    /**
427     * Visits a FieldInstruction.
428     *
429     * @param obj the instruction.
430     */
431    void visitFieldInstruction(FieldInstruction obj);
432
433    /**
434     * Visits a FieldOrMethod.
435     *
436     * @param obj the instruction.
437     */
438    void visitFieldOrMethod(FieldOrMethod obj);
439
440    /**
441     * Visits an FLOAD instruction.
442     *
443     * @param obj the instruction.
444     */
445    void visitFLOAD(FLOAD obj);
446
447    /**
448     * Visits an FMUL instruction.
449     *
450     * @param obj the instruction.
451     */
452    void visitFMUL(FMUL obj);
453
454    /**
455     * Visits an FNEG instruction.
456     *
457     * @param obj the instruction.
458     */
459    void visitFNEG(FNEG obj);
460
461    /**
462     * Visits an FREM instruction.
463     *
464     * @param obj the instruction.
465     */
466    void visitFREM(FREM obj);
467
468    /**
469     * Visits an FRETURN instruction.
470     *
471     * @param obj the instruction.
472     */
473    void visitFRETURN(FRETURN obj);
474
475    /**
476     * Visits an FSTORE instruction.
477     *
478     * @param obj the instruction.
479     */
480    void visitFSTORE(FSTORE obj);
481
482    /**
483     * Visits an FSUB instruction.
484     *
485     * @param obj the instruction.
486     */
487    void visitFSUB(FSUB obj);
488
489    /**
490     * Visits a GETFIELD instruction.
491     *
492     * @param obj the instruction.
493     */
494    void visitGETFIELD(GETFIELD obj);
495
496    /**
497     * Visits a GETSTATIC instruction.
498     *
499     * @param obj the instruction.
500     */
501    void visitGETSTATIC(GETSTATIC obj);
502
503    /**
504     * Visits a GOTO instruction.
505     *
506     * @param obj the instruction.
507     */
508    void visitGOTO(GOTO obj);
509
510    /**
511     * Visits a GOTO_W instruction.
512     *
513     * @param obj the instruction.
514     */
515    void visitGOTO_W(GOTO_W obj);
516
517    /**
518     * Visits a GotoInstruction.
519     *
520     * @param obj the instruction.
521     */
522    void visitGotoInstruction(GotoInstruction obj);
523
524    /**
525     * Visits an I2B instruction.
526     *
527     * @param obj the instruction.
528     */
529    void visitI2B(I2B obj);
530
531    /**
532     * Visits an I2C instruction.
533     *
534     * @param obj the instruction.
535     */
536    void visitI2C(I2C obj);
537
538    /**
539     * Visits an I2D instruction.
540     *
541     * @param obj the instruction.
542     */
543    void visitI2D(I2D obj);
544
545    /**
546     * Visits an I2F instruction.
547     *
548     * @param obj the instruction.
549     */
550    void visitI2F(I2F obj);
551
552    /**
553     * Visits an I2L instruction.
554     *
555     * @param obj the instruction.
556     */
557    void visitI2L(I2L obj);
558
559    /**
560     * Visits an I2S instruction.
561     *
562     * @param obj the instruction.
563     */
564    void visitI2S(I2S obj);
565
566    /**
567     * Visits an IADD instruction.
568     *
569     * @param obj the instruction.
570     */
571    void visitIADD(IADD obj);
572
573    /**
574     * Visits an IALOAD instruction.
575     *
576     * @param obj the instruction.
577     */
578    void visitIALOAD(IALOAD obj);
579
580    /**
581     * Visits an IAND instruction.
582     *
583     * @param obj the instruction.
584     */
585    void visitIAND(IAND obj);
586
587    /**
588     * Visits an IASTORE instruction.
589     *
590     * @param obj the instruction.
591     */
592    void visitIASTORE(IASTORE obj);
593
594    /**
595     * Visits an ICONST instruction.
596     *
597     * @param obj the instruction.
598     */
599    void visitICONST(ICONST obj);
600
601    /**
602     * Visits an IDIV instruction.
603     *
604     * @param obj the instruction.
605     */
606    void visitIDIV(IDIV obj);
607
608    /**
609     * Visits an IF_ACMPEQ instruction.
610     *
611     * @param obj the instruction.
612     */
613    void visitIF_ACMPEQ(IF_ACMPEQ obj);
614
615    /**
616     * Visits an IF_ACMPNE instruction.
617     *
618     * @param obj the instruction.
619     */
620    void visitIF_ACMPNE(IF_ACMPNE obj);
621
622    /**
623     * Visits an IF_ICMPEQ instruction.
624     *
625     * @param obj the instruction.
626     */
627    void visitIF_ICMPEQ(IF_ICMPEQ obj);
628
629    /**
630     * Visits an IF_ICMPGE instruction.
631     *
632     * @param obj the instruction.
633     */
634    void visitIF_ICMPGE(IF_ICMPGE obj);
635
636    /**
637     * Visits an IF_ICMPGT instruction.
638     *
639     * @param obj the instruction.
640     */
641    void visitIF_ICMPGT(IF_ICMPGT obj);
642
643    /**
644     * Visits an IF_ICMPLE instruction.
645     *
646     * @param obj the instruction.
647     */
648    void visitIF_ICMPLE(IF_ICMPLE obj);
649
650    /**
651     * Visits an IF_ICMPLT instruction.
652     *
653     * @param obj the instruction.
654     */
655    void visitIF_ICMPLT(IF_ICMPLT obj);
656
657    /**
658     * Visits an IF_ICMPNE instruction.
659     *
660     * @param obj the instruction.
661     */
662    void visitIF_ICMPNE(IF_ICMPNE obj);
663
664    /**
665     * Visits an IFEQ instruction.
666     *
667     * @param obj the instruction.
668     */
669    void visitIFEQ(IFEQ obj);
670
671    /**
672     * Visits an IFGE instruction.
673     *
674     * @param obj the instruction.
675     */
676    void visitIFGE(IFGE obj);
677
678    /**
679     * Visits an IFGT instruction.
680     *
681     * @param obj the instruction.
682     */
683    void visitIFGT(IFGT obj);
684
685    /**
686     * Visits an IfInstruction.
687     *
688     * @param obj the instruction.
689     */
690    void visitIfInstruction(IfInstruction obj);
691
692    /**
693     * Visits an IFLE instruction.
694     *
695     * @param obj the instruction.
696     */
697    void visitIFLE(IFLE obj);
698
699    /**
700     * Visits an IFLT instruction.
701     *
702     * @param obj the instruction.
703     */
704    void visitIFLT(IFLT obj);
705
706    /**
707     * Visits an IFNE instruction.
708     *
709     * @param obj the instruction.
710     */
711    void visitIFNE(IFNE obj);
712
713    /**
714     * Visits an IFNONNULL instruction.
715     *
716     * @param obj the instruction.
717     */
718    void visitIFNONNULL(IFNONNULL obj);
719
720    /**
721     * Visits an IFNULL instruction.
722     *
723     * @param obj the instruction.
724     */
725    void visitIFNULL(IFNULL obj);
726
727    /**
728     * Visits an IINC instruction.
729     *
730     * @param obj the instruction.
731     */
732    void visitIINC(IINC obj);
733
734    /**
735     * Visits an ILOAD instruction.
736     *
737     * @param obj the instruction.
738     */
739    void visitILOAD(ILOAD obj);
740
741    /**
742     * Visits an IMPDEP1 instruction.
743     *
744     * @param obj the instruction.
745     */
746    void visitIMPDEP1(IMPDEP1 obj);
747
748    /**
749     * Visits an IMPDEP2 instruction.
750     *
751     * @param obj the instruction.
752     */
753    void visitIMPDEP2(IMPDEP2 obj);
754
755    /**
756     * Visits an IMUL instruction.
757     *
758     * @param obj the instruction.
759     */
760    void visitIMUL(IMUL obj);
761
762    /**
763     * Visits an INEG instruction.
764     *
765     * @param obj the instruction.
766     */
767    void visitINEG(INEG obj);
768
769    /**
770     * Visits an INSTANCEOF instruction.
771     *
772     * @param obj the instruction.
773     */
774    void visitINSTANCEOF(INSTANCEOF obj);
775
776    /**
777     * Visits an INVOKEDYNAMIC instruction.
778     *
779     * @param obj the instruction.
780     * @since 6.0
781     */
782    void visitINVOKEDYNAMIC(INVOKEDYNAMIC obj);
783
784    /**
785     * Visits an InvokeInstruction.
786     *
787     * @param obj the instruction.
788     */
789    void visitInvokeInstruction(InvokeInstruction obj);
790
791    /**
792     * Visits an INVOKEINTERFACE instruction.
793     *
794     * @param obj the instruction.
795     */
796    void visitINVOKEINTERFACE(INVOKEINTERFACE obj);
797
798    /**
799     * Visits an INVOKESPECIAL instruction.
800     *
801     * @param obj the instruction.
802     */
803    void visitINVOKESPECIAL(INVOKESPECIAL obj);
804
805    /**
806     * Visits an INVOKESTATIC instruction.
807     *
808     * @param obj the instruction.
809     */
810    void visitINVOKESTATIC(INVOKESTATIC obj);
811
812    /**
813     * Visits an INVOKEVIRTUAL instruction.
814     *
815     * @param obj the instruction.
816     */
817    void visitINVOKEVIRTUAL(INVOKEVIRTUAL obj);
818
819    /**
820     * Visits an IOR instruction.
821     *
822     * @param obj the instruction.
823     */
824    void visitIOR(IOR obj);
825
826    /**
827     * Visits an IREM instruction.
828     *
829     * @param obj the instruction.
830     */
831    void visitIREM(IREM obj);
832
833    /**
834     * Visits an IRETURN instruction.
835     *
836     * @param obj the instruction.
837     */
838    void visitIRETURN(IRETURN obj);
839
840    /**
841     * Visits an ISHL instruction.
842     *
843     * @param obj the instruction.
844     */
845    void visitISHL(ISHL obj);
846
847    /**
848     * Visits an ISHR instruction.
849     *
850     * @param obj the instruction.
851     */
852    void visitISHR(ISHR obj);
853
854    /**
855     * Visits an ISTORE instruction.
856     *
857     * @param obj the instruction.
858     */
859    void visitISTORE(ISTORE obj);
860
861    /**
862     * Visits an ISUB instruction.
863     *
864     * @param obj the instruction.
865     */
866    void visitISUB(ISUB obj);
867
868    /**
869     * Visits an IUSHR instruction.
870     *
871     * @param obj the instruction.
872     */
873    void visitIUSHR(IUSHR obj);
874
875    /**
876     * Visits an IXOR instruction.
877     *
878     * @param obj the instruction.
879     */
880    void visitIXOR(IXOR obj);
881
882    /**
883     * Visits a JSR instruction.
884     *
885     * @param obj the instruction.
886     */
887    void visitJSR(JSR obj);
888
889    /**
890     * Visits a JSR_W instruction.
891     *
892     * @param obj the instruction.
893     */
894    void visitJSR_W(JSR_W obj);
895
896    /**
897     * Visits a JsrInstruction.
898     *
899     * @param obj the instruction.
900     */
901    void visitJsrInstruction(JsrInstruction obj);
902
903    /**
904     * Visits an L2D instruction.
905     *
906     * @param obj the instruction.
907     */
908    void visitL2D(L2D obj);
909
910    /**
911     * Visits an L2F instruction.
912     *
913     * @param obj the instruction.
914     */
915    void visitL2F(L2F obj);
916
917    /**
918     * Visits an L2I instruction.
919     *
920     * @param obj the instruction.
921     */
922    void visitL2I(L2I obj);
923
924    /**
925     * Visits an LADD instruction.
926     *
927     * @param obj the instruction.
928     */
929    void visitLADD(LADD obj);
930
931    /**
932     * Visits an LALOAD instruction.
933     *
934     * @param obj the instruction.
935     */
936    void visitLALOAD(LALOAD obj);
937
938    /**
939     * Visits an LAND instruction.
940     *
941     * @param obj the instruction.
942     */
943    void visitLAND(LAND obj);
944
945    /**
946     * Visits an LASTORE instruction.
947     *
948     * @param obj the instruction.
949     */
950    void visitLASTORE(LASTORE obj);
951
952    /**
953     * Visits an LCMP instruction.
954     *
955     * @param obj the instruction.
956     */
957    void visitLCMP(LCMP obj);
958
959    /**
960     * Visits an LCONST instruction.
961     *
962     * @param obj the instruction.
963     */
964    void visitLCONST(LCONST obj);
965
966    /**
967     * Visits an LDC instruction.
968     *
969     * @param obj the instruction.
970     */
971    void visitLDC(LDC obj);
972
973    /**
974     * Visits an LDC2_W instruction.
975     *
976     * @param obj the instruction.
977     */
978    void visitLDC2_W(LDC2_W obj);
979
980    /**
981     * Visits an LDIV instruction.
982     *
983     * @param obj the instruction.
984     */
985    void visitLDIV(LDIV obj);
986
987    /**
988     * Visits an LLOAD instruction.
989     *
990     * @param obj the instruction.
991     */
992    void visitLLOAD(LLOAD obj);
993
994    /**
995     * Visits an LMUL instruction.
996     *
997     * @param obj the instruction.
998     */
999    void visitLMUL(LMUL obj);
1000
1001    /**
1002     * Visits an LNEG instruction.
1003     *
1004     * @param obj the instruction.
1005     */
1006    void visitLNEG(LNEG obj);
1007
1008    /**
1009     * Visits a LoadClass.
1010     *
1011     * @param obj the load class.
1012     */
1013    void visitLoadClass(LoadClass obj);
1014
1015    /**
1016     * Visits a LoadInstruction.
1017     *
1018     * @param obj the instruction.
1019     */
1020    void visitLoadInstruction(LoadInstruction obj);
1021
1022    /**
1023     * Visits a LocalVariableInstruction.
1024     *
1025     * @param obj the instruction.
1026     */
1027    void visitLocalVariableInstruction(LocalVariableInstruction obj);
1028
1029    /**
1030     * Visits a LOOKUPSWITCH instruction.
1031     *
1032     * @param obj the instruction.
1033     */
1034    void visitLOOKUPSWITCH(LOOKUPSWITCH obj);
1035
1036    /**
1037     * Visits an LOR instruction.
1038     *
1039     * @param obj the instruction.
1040     */
1041    void visitLOR(LOR obj);
1042
1043    /**
1044     * Visits an LREM instruction.
1045     *
1046     * @param obj the instruction.
1047     */
1048    void visitLREM(LREM obj);
1049
1050    /**
1051     * Visits an LRETURN instruction.
1052     *
1053     * @param obj the instruction.
1054     */
1055    void visitLRETURN(LRETURN obj);
1056
1057    /**
1058     * Visits an LSHL instruction.
1059     *
1060     * @param obj the instruction.
1061     */
1062    void visitLSHL(LSHL obj);
1063
1064    /**
1065     * Visits an LSHR instruction.
1066     *
1067     * @param obj the instruction.
1068     */
1069    void visitLSHR(LSHR obj);
1070
1071    /**
1072     * Visits an LSTORE instruction.
1073     *
1074     * @param obj the instruction.
1075     */
1076    void visitLSTORE(LSTORE obj);
1077
1078    /**
1079     * Visits an LSUB instruction.
1080     *
1081     * @param obj the instruction.
1082     */
1083    void visitLSUB(LSUB obj);
1084
1085    /**
1086     * Visits an LUSHR instruction.
1087     *
1088     * @param obj the instruction.
1089     */
1090    void visitLUSHR(LUSHR obj);
1091
1092    /**
1093     * Visits an LXOR instruction.
1094     *
1095     * @param obj the instruction.
1096     */
1097    void visitLXOR(LXOR obj);
1098
1099    /**
1100     * Visits a MONITORENTER instruction.
1101     *
1102     * @param obj the instruction.
1103     */
1104    void visitMONITORENTER(MONITORENTER obj);
1105
1106    /**
1107     * Visits a MONITOREXIT instruction.
1108     *
1109     * @param obj the instruction.
1110     */
1111    void visitMONITOREXIT(MONITOREXIT obj);
1112
1113    /**
1114     * Visits a MULTIANEWARRAY instruction.
1115     *
1116     * @param obj the instruction.
1117     */
1118    void visitMULTIANEWARRAY(MULTIANEWARRAY obj);
1119
1120    /**
1121     * Visits a NEW instruction.
1122     *
1123     * @param obj the instruction.
1124     */
1125    void visitNEW(NEW obj);
1126
1127    /**
1128     * Visits a NEWARRAY instruction.
1129     *
1130     * @param obj the instruction.
1131     */
1132    void visitNEWARRAY(NEWARRAY obj);
1133
1134    /**
1135     * Visits a NOP instruction.
1136     *
1137     * @param obj the instruction.
1138     */
1139    void visitNOP(NOP obj);
1140
1141    /**
1142     * Visits a POP instruction.
1143     *
1144     * @param obj the instruction.
1145     */
1146    void visitPOP(POP obj);
1147
1148    /**
1149     * Visits a POP2 instruction.
1150     *
1151     * @param obj the instruction.
1152     */
1153    void visitPOP2(POP2 obj);
1154
1155    /**
1156     * Visits a PopInstruction.
1157     *
1158     * @param obj the instruction.
1159     */
1160    void visitPopInstruction(PopInstruction obj);
1161
1162    /**
1163     * Visits a PushInstruction.
1164     *
1165     * @param obj the instruction.
1166     */
1167    void visitPushInstruction(PushInstruction obj);
1168
1169    /**
1170     * Visits a PUTFIELD instruction.
1171     *
1172     * @param obj the instruction.
1173     */
1174    void visitPUTFIELD(PUTFIELD obj);
1175
1176    /**
1177     * Visits a PUTSTATIC instruction.
1178     *
1179     * @param obj the instruction.
1180     */
1181    void visitPUTSTATIC(PUTSTATIC obj);
1182
1183    /**
1184     * Visits a RET instruction.
1185     *
1186     * @param obj the instruction.
1187     */
1188    void visitRET(RET obj);
1189
1190    /**
1191     * Visits a RETURN instruction.
1192     *
1193     * @param obj the instruction.
1194     */
1195    void visitRETURN(RETURN obj);
1196
1197    /**
1198     * Visits a ReturnInstruction.
1199     *
1200     * @param obj the instruction.
1201     */
1202    void visitReturnInstruction(ReturnInstruction obj);
1203
1204    /**
1205     * Visits a SALOAD instruction.
1206     *
1207     * @param obj the instruction.
1208     */
1209    void visitSALOAD(SALOAD obj);
1210
1211    /**
1212     * Visits a SASTORE instruction.
1213     *
1214     * @param obj the instruction.
1215     */
1216    void visitSASTORE(SASTORE obj);
1217
1218    /**
1219     * Visits a Select instruction.
1220     *
1221     * @param obj the instruction.
1222     */
1223    void visitSelect(Select obj);
1224
1225    /**
1226     * Visits a SIPUSH instruction.
1227     *
1228     * @param obj the instruction.
1229     */
1230    void visitSIPUSH(SIPUSH obj);
1231
1232    /**
1233     * Visits a StackConsumer.
1234     *
1235     * @param obj the instruction.
1236     */
1237    void visitStackConsumer(StackConsumer obj);
1238
1239    /**
1240     * Visits a StackInstruction.
1241     *
1242     * @param obj the instruction.
1243     */
1244    void visitStackInstruction(StackInstruction obj);
1245
1246    /**
1247     * Visits a StackProducer.
1248     *
1249     * @param obj the instruction.
1250     */
1251    void visitStackProducer(StackProducer obj);
1252
1253    /**
1254     * Visits a StoreInstruction.
1255     *
1256     * @param obj the instruction.
1257     */
1258    void visitStoreInstruction(StoreInstruction obj);
1259
1260    /**
1261     * Visits a SWAP instruction.
1262     *
1263     * @param obj the instruction.
1264     */
1265    void visitSWAP(SWAP obj);
1266
1267    /**
1268     * Visits a TABLESWITCH instruction.
1269     *
1270     * @param obj the instruction.
1271     */
1272    void visitTABLESWITCH(TABLESWITCH obj);
1273
1274    /**
1275     * Visits a TypedInstruction.
1276     *
1277     * @param obj the instruction.
1278     */
1279    void visitTypedInstruction(TypedInstruction obj);
1280
1281    /**
1282     * Visits an UnconditionalBranch.
1283     *
1284     * @param obj the instruction.
1285     */
1286    void visitUnconditionalBranch(UnconditionalBranch obj);
1287
1288    /**
1289     * Visits a VariableLengthInstruction.
1290     *
1291     * @param obj the instruction.
1292     */
1293    void visitVariableLengthInstruction(VariableLengthInstruction obj);
1294}