API tools faq
paste
Advertisement
PROgrm_JARvis

Magic hell

PROgrm_JARvis
Oct 14th, 2019
116
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 17.71 KB | None | 0 0
raw download clone embed print report
  1. package ru.progrm_jarvis.asminj.tools.instruction;
  2.  
  3. import lombok.NonNull;
  4. import lombok.experimental.UtilityClass;
  5. import lombok.val;
  6. import lombok.var;
  7. import org.objectweb.asm.MethodVisitor;
  8. import ru.progrm_jarvis.asminj.tools.instruction.serialization.InstructionDecoderException;
  9. import ru.progrm_jarvis.asminj.tools.instruction.serialization.SimpleOperandReader;
  10.  
  11. import java.util.Locale;
  12.  
  13. import static org.objectweb.asm.Opcodes.*;
  14.  
  15. @UtilityClass
  16. public class InstructionParser {
  17.  
  18.     @SuppressWarnings("SpellCheckingInspection") // instruction names
  19.     public void insertRawBytecode(@NonNull final MethodVisitor method, @NonNull String instruction) {
  20.         instruction = instruction.trim(); // both side spaces
  21.         var delimiter = instruction.indexOf(' ');
  22.  
  23.         // without operands
  24.         if (delimiter == -1) switch (instruction.toUpperCase(Locale.US)) {
  25.             // <editor-fold desc="No-operand opcode names" defaultstate="collapsed">
  26.             case "AALOAD": {
  27.                 method.visitInsn(AALOAD);
  28.                 return;
  29.             }
  30.             case "AASTORE": {
  31.                 method.visitInsn(AASTORE);
  32.                 return;
  33.             }
  34.             case "ACONST_NULL": {
  35.                 method.visitInsn(ACONST_NULL);
  36.                 return;
  37.             }
  38.             case "ALOAD_0": {
  39.                 method.visitVarInsn(ALOAD, 0);
  40.                 return;
  41.             }
  42.             case "ALOAD_1": {
  43.                 method.visitVarInsn(ALOAD, 1);
  44.                 return;
  45.             }
  46.             case "ALOAD_2": {
  47.                 method.visitVarInsn(ALOAD, 2);
  48.                 return;
  49.             }
  50.             case "ALOAD_3": {
  51.                 method.visitVarInsn(ALOAD, 3);
  52.                 return;
  53.             }
  54.             case "ARETURN": {
  55.                 method.visitInsn(ARETURN);
  56.                 return;
  57.             }
  58.             case "ARRAYLENGTH": {
  59.                 method.visitInsn(ARRAYLENGTH);
  60.                 return;
  61.             }
  62.             case "ASTORE_0": {
  63.                 method.visitVarInsn(ASTORE, 0);
  64.                 return;
  65.             }
  66.             case "ASTORE_1": {
  67.                 method.visitVarInsn(ASTORE, 1);
  68.                 return;
  69.             }
  70.             case "ASTORE_2": {
  71.                 method.visitVarInsn(ASTORE, 2);
  72.                 return;
  73.             }
  74.             case "ASTORE_3": {
  75.                 method.visitVarInsn(ASTORE, 3);
  76.                 return;
  77.             }
  78.             case "ATHROW": {
  79.                 method.visitInsn(ATHROW);
  80.                 return;
  81.             }
  82.             case "BALOAD": {
  83.                 method.visitInsn(BALOAD);
  84.                 return;
  85.             }
  86.             case "BASTORE": {
  87.                 method.visitInsn(BASTORE);
  88.                 return;
  89.             }
  90.             case "BREAKPOINT": {
  91.                 method.visitInsn(0xCA);
  92.                 return;
  93.             }
  94.             case "CALOAD": {
  95.                 method.visitInsn(CALOAD);
  96.                 return;
  97.             }
  98.             case "CASTORE": {
  99.                 method.visitInsn(CASTORE);
  100.                 return;
  101.             }
  102.             case "D2F": {
  103.                 method.visitInsn(D2F);
  104.                 return;
  105.             }
  106.             case "D2I": {
  107.                 method.visitInsn(D2I);
  108.                 return;
  109.             }
  110.             case "D2L": {
  111.                 method.visitInsn(D2L);
  112.                 return;
  113.             }
  114.             case "DADD": {
  115.                 method.visitInsn(DADD);
  116.                 return;
  117.             }
  118.             case "DALOAD": {
  119.                 method.visitInsn(DALOAD);
  120.                 return;
  121.             }
  122.             case "DASTORE": {
  123.                 method.visitInsn(DASTORE);
  124.                 return;
  125.             }
  126.             case "DCMPG": {
  127.                 method.visitInsn(DCMPG);
  128.                 return;
  129.             }
  130.             case "DCMPL": {
  131.                 method.visitInsn(DCMPG);
  132.                 return;
  133.             }
  134.             case "DCONST_0": {
  135.                 method.visitInsn(DCONST_0);
  136.                 return;
  137.             }
  138.             case "DCONST_1": {
  139.                 method.visitInsn(DCONST_1);
  140.                 return;
  141.             }
  142.             case "DDIV": {
  143.                 method.visitInsn(DDIV);
  144.                 return;
  145.             }
  146.             case "DLOAD_0": {
  147.                 method.visitVarInsn(DLOAD, 0);
  148.                 return;
  149.             }
  150.             case "DLOAD_1": {
  151.                 method.visitVarInsn(DLOAD, 1);
  152.                 return;
  153.             }
  154.             case "DLOAD_2": {
  155.                 method.visitVarInsn(DLOAD, 2);
  156.                 return;
  157.             }
  158.             case "DLOAD_3": {
  159.                 method.visitVarInsn(DLOAD, 3);
  160.                 return;
  161.             }
  162.             case "DMUL": {
  163.                 method.visitInsn(DMUL);
  164.                 return;
  165.             }
  166.             case "DNEG": {
  167.                 method.visitInsn(DNEG);
  168.                 return;
  169.             }
  170.             case "DREM": {
  171.                 method.visitInsn(DREM);
  172.                 return;
  173.             }
  174.             case "DRETURN": {
  175.                 method.visitInsn(DRETURN);
  176.                 return;
  177.             }
  178.             case "DSTORE_0": {
  179.                 method.visitVarInsn(DSTORE, 0);
  180.                 return;
  181.             }
  182.             case "DSTORE_1": {
  183.                 method.visitVarInsn(DSTORE, 1);
  184.                 return;
  185.             }
  186.             case "DSTORE_2": {
  187.                 method.visitVarInsn(DSTORE, 2);
  188.                 return;
  189.             }
  190.             case "DSTORE_3": {
  191.                 method.visitVarInsn(DSTORE, 3);
  192.                 return;
  193.             }
  194.             case "DSUB": {
  195.                 method.visitInsn(DREM);
  196.                 return;
  197.             }
  198.             case "DUP": {
  199.                 method.visitInsn(DUP);
  200.                 return;
  201.             }
  202.             case "DUP_X1": {
  203.                 method.visitInsn(DUP_X1);
  204.                 return;
  205.             }
  206.             case "DUP2": {
  207.                 method.visitInsn(DUP2);
  208.                 return;
  209.             }
  210.             case "DUP2_X1": {
  211.                 method.visitInsn(DUP2_X1);
  212.                 return;
  213.             }
  214.             case "DUP2_X2": {
  215.                 method.visitInsn(DUP2_X2);
  216.                 return;
  217.             }
  218.             case "F2D": {
  219.                 method.visitInsn(F2D);
  220.                 return;
  221.             }
  222.             case "F2I": {
  223.                 method.visitInsn(F2I);
  224.                 return;
  225.             }
  226.             case "F2L": {
  227.                 method.visitInsn(F2L);
  228.                 return;
  229.             }
  230.             case "FADD": {
  231.                 method.visitInsn(FADD);
  232.                 return;
  233.             }
  234.             case "FALOAD": {
  235.                 method.visitInsn(FALOAD);
  236.                 return;
  237.             }
  238.             case "FASTORE": {
  239.                 method.visitInsn(FASTORE);
  240.                 return;
  241.             }
  242.             case "FLOAD_0": {
  243.                 method.visitVarInsn(FLOAD, 0);
  244.                 return;
  245.             }
  246.             case "FLOAD_1": {
  247.                 method.visitVarInsn(FLOAD, 1);
  248.                 return;
  249.             }
  250.             case "FLOAD_2": {
  251.                 method.visitVarInsn(FLOAD, 2);
  252.                 return;
  253.             }
  254.             case "FLOAD_3": {
  255.                 method.visitVarInsn(FLOAD, 2);
  256.                 return;
  257.             }
  258.             case "FMUL": {
  259.                 method.visitInsn(FMUL);
  260.                 return;
  261.             }
  262.             case "FNEG": {
  263.                 method.visitInsn(FNEG);
  264.                 return;
  265.             }
  266.             case "FREM": {
  267.                 method.visitInsn(FREM);
  268.                 return;
  269.             }
  270.             case "FRETURN": {
  271.                 method.visitInsn(FRETURN);
  272.                 return;
  273.             }
  274.             case "FSTORE_0": {
  275.                 method.visitVarInsn(FSTORE, 0);
  276.                 return;
  277.             }
  278.             case "FSTORE_1": {
  279.                 method.visitVarInsn(FSTORE, 1);
  280.                 return;
  281.             }
  282.             case "FSTORE_2": {
  283.                 method.visitVarInsn(FSTORE, 2);
  284.                 return;
  285.             }
  286.             case "FSTORE_3": {
  287.                 method.visitVarInsn(FSTORE, 3);
  288.                 return;
  289.             }
  290.             case "FSUB": {
  291.                 method.visitInsn(FSUB);
  292.                 return;
  293.             }
  294.             case "I2B": {
  295.                 method.visitInsn(I2B);
  296.                 return;
  297.             }
  298.             case "I2C": {
  299.                 method.visitInsn(I2C);
  300.                 return;
  301.             }
  302.             case "I2D": {
  303.                 method.visitInsn(I2D);
  304.                 return;
  305.             }
  306.             case "I2F": {
  307.                 method.visitInsn(I2F);
  308.                 return;
  309.             }
  310.             case "I2L": {
  311.                 method.visitInsn(I2L);
  312.                 return;
  313.             }
  314.             case "I2S": {
  315.                 method.visitInsn(I2S);
  316.                 return;
  317.             }
  318.             case "IADD": {
  319.                 method.visitInsn(IADD);
  320.                 return;
  321.             }
  322.             case "IALOAD": {
  323.                 method.visitInsn(IALOAD);
  324.                 return;
  325.             }
  326.             case "IAND": {
  327.                 method.visitInsn(IAND);
  328.                 return;
  329.             }
  330.             case "IASTORE": {
  331.                 method.visitInsn(IASTORE);
  332.                 return;
  333.             }
  334.             case "ICONST_M1": {
  335.                 method.visitInsn(ICONST_M1);
  336.                 return;
  337.             }
  338.             case "ICONST_0": {
  339.                 method.visitInsn(ICONST_0);
  340.                 return;
  341.             }
  342.             case "ICONST_1": {
  343.                 method.visitInsn(ICONST_1);
  344.                 return;
  345.             }
  346.             case "ICONST_2": {
  347.                 method.visitInsn(ICONST_2);
  348.                 return;
  349.             }
  350.             case "ICONST_3": {
  351.                 method.visitInsn(ICONST_3);
  352.                 return;
  353.             }
  354.             case "ICONST_4": {
  355.                 method.visitInsn(ICONST_4);
  356.                 return;
  357.             }
  358.             case "ICONST_5": {
  359.                 method.visitInsn(ICONST_5);
  360.                 return;
  361.             }
  362.             case "IDIV": {
  363.                 method.visitInsn(IDIV);
  364.                 return;
  365.             }
  366.             case "ILOAD_0": {
  367.                 method.visitVarInsn(ILOAD, 0);
  368.                 return;
  369.             }
  370.             case "ILOAD_1": {
  371.                 method.visitVarInsn(ILOAD, 1);
  372.                 return;
  373.             }
  374.             case "ILOAD_2": {
  375.                 method.visitVarInsn(ILOAD, 2);
  376.                 return;
  377.             }
  378.             case "ILOAD_3": {
  379.                 method.visitVarInsn(ILOAD, 3);
  380.                 return;
  381.             }
  382.             case "IMPDEP1": {
  383.                 method.visitInsn(0xFE);
  384.                 return;
  385.             }
  386.             case "IMPDEP2": {
  387.                 method.visitInsn(0xFF);
  388.                 return;
  389.             }
  390.             case "IMUL": {
  391.                 method.visitInsn(IMUL);
  392.                 return;
  393.             }
  394.             case "INEG": {
  395.                 method.visitInsn(INEG);
  396.                 return;
  397.             }
  398.             case "IOR": {
  399.                 method.visitInsn(IOR);
  400.                 return;
  401.             }
  402.             case "IREM": {
  403.                 method.visitInsn(IREM);
  404.                 return;
  405.             }
  406.             case "IRETURN": {
  407.                 method.visitInsn(IRETURN);
  408.                 return;
  409.             }
  410.             case "ISHL": {
  411.                 method.visitInsn(ISHL);
  412.                 return;
  413.             }
  414.             case "ISHR": {
  415.                 method.visitInsn(ISHR);
  416.                 return;
  417.             }
  418.             case "ISTORE_0": {
  419.                 method.visitVarInsn(ISTORE, 0);
  420.                 return;
  421.             }
  422.             case "ISTORE_1": {
  423.                 method.visitVarInsn(ISTORE, 1);
  424.                 return;
  425.             }
  426.             case "ISTORE_2": {
  427.                 method.visitVarInsn(ISTORE, 2);
  428.                 return;
  429.             }
  430.             case "ISTORE_3": {
  431.                 method.visitVarInsn(ISTORE, 3);
  432.                 return;
  433.             }
  434.             case "ISUB": {
  435.                 method.visitInsn(ISUB);
  436.                 return;
  437.             }
  438.             case "IUSHR": {
  439.                 method.visitInsn(IUSHR);
  440.                 return;
  441.             }
  442.             case "IXOR": {
  443.                 method.visitInsn(IXOR);
  444.                 return;
  445.             }
  446.             case "L2D": {
  447.                 method.visitInsn(L2D);
  448.                 return;
  449.             }
  450.             case "L2F": {
  451.                 method.visitInsn(L2F);
  452.                 return;
  453.             }
  454.             case "L2I": {
  455.                 method.visitInsn(L2I);
  456.                 return;
  457.             }
  458.             case "LADD": {
  459.                 method.visitInsn(LADD);
  460.                 return;
  461.             }
  462.             case "LALOAD": {
  463.                 method.visitInsn(LALOAD);
  464.                 return;
  465.             }
  466.             case "LAND": {
  467.                 method.visitInsn(LAND);
  468.                 return;
  469.             }
  470.             case "LASTORE": {
  471.                 method.visitInsn(LASTORE);
  472.                 return;
  473.             }
  474.             case "LCMP": {
  475.                 method.visitInsn(LCMP);
  476.                 return;
  477.             }
  478.             case "LCONST_0": {
  479.                 method.visitInsn(LCONST_0);
  480.                 return;
  481.             }
  482.             case "LCONST_1": {
  483.                 method.visitInsn(LCONST_1);
  484.                 return;
  485.             }
  486.             case "LDIV": {
  487.                 method.visitInsn(LDIV);
  488.                 return;
  489.             }
  490.             case "LLOAD_0": {
  491.                 method.visitVarInsn(LLOAD, 0);
  492.                 return;
  493.             }
  494.             case "LLOAD_1": {
  495.                 method.visitVarInsn(LLOAD, 1);
  496.                 return;
  497.             }
  498.             case "LLOAD_2": {
  499.                 method.visitVarInsn(LLOAD, 2);
  500.                 return;
  501.             }
  502.             case "LLOAD_3": {
  503.                 method.visitVarInsn(LLOAD, 3);
  504.                 return;
  505.             }
  506.             case "LMUL": {
  507.                 method.visitInsn(LMUL);
  508.                 return;
  509.             }
  510.             case "LNEG": {
  511.                 method.visitInsn(LNEG);
  512.                 return;
  513.             }
  514.             case "LOR": {
  515.                 method.visitInsn(LOR);
  516.                 return;
  517.             }
  518.             case "LREM": {
  519.                 method.visitInsn(LREM);
  520.                 return;
  521.             }
  522.             case "LRETURN": {
  523.                 method.visitInsn(LRETURN);
  524.                 return;
  525.             }
  526.             case "LSHL": {
  527.                 method.visitInsn(LSHL);
  528.                 return;
  529.             }
  530.             case "LSHR": {
  531.                 method.visitInsn(LSHR);
  532.                 return;
  533.             }
  534.             case "LSTORE_0": {
  535.                 method.visitVarInsn(LSTORE, 0);
  536.                 return;
  537.             }
  538.             case "LSTORE_1": {
  539.                 method.visitVarInsn(LSTORE, 1);
  540.                 return;
  541.             }
  542.             case "LSTORE_2": {
  543.                 method.visitVarInsn(LSTORE, 2);
  544.                 return;
  545.             }
  546.             case "LSTORE_3": {
  547.                 method.visitVarInsn(LSTORE, 3);
  548.                 return;
  549.             }
  550.             case "LSUB": {
  551.                 method.visitInsn(LSUB);
  552.                 return;
  553.             }
  554.             case "LUSHR": {
  555.                 method.visitInsn(LUSHR);
  556.                 return;
  557.             }
  558.             case "LXOR": {
  559.                 method.visitInsn(LXOR);
  560.                 return;
  561.             }
  562.             case "MONITORENTER": {
  563.                 method.visitInsn(MONITORENTER);
  564.                 return;
  565.             }
  566.             case "MONITOREXIT": {
  567.                 method.visitInsn(MONITOREXIT);
  568.                 return;
  569.             }
  570.             case "NOP": {
  571.                 method.visitInsn(NOP);
  572.                 return;
  573.             }
  574.             case "POP": {
  575.                 method.visitInsn(POP);
  576.                 return;
  577.             }
  578.             case "POP2": {
  579.                 method.visitInsn(POP2);
  580.                 return;
  581.             }
  582.             case "RETURN": {
  583.                 method.visitInsn(RETURN);
  584.                 return;
  585.             }
  586.             case "SALOAD": {
  587.                 method.visitInsn(SALOAD);
  588.                 return;
  589.             }
  590.             case "SASTORE": {
  591.                 method.visitInsn(SASTORE);
  592.                 return;
  593.             }
  594.             case "SWAP": {
  595.                 method.visitInsn(SWAP);
  596.                 return;
  597.             }
  598.             default: throw new InstructionDecoderException(
  599.                     "Unable to find no-operand OPCODE <" + instruction + '>'
  600.             );
  601.             // </editor-fold>
  602.         }
  603.         // with oppperands
  604.         else { // there are arguments
  605.             val operators = SimpleOperandReader.from(instruction.substring(delimiter));
  606.             switch (instruction.substring(0, delimiter).toUpperCase(Locale.US)) {
  607.                 case "ALOAD": {
  608.                     method.visitVarInsn(ALOAD, operators.readInt());
  609.                     return;
  610.                 }
  611.                 case "ANEWARRAY": {
  612.                     method.visitTypeInsn(ANEWARRAY, operators.readInternalClassName());
  613.                     return;
  614.                 }
  615.                 // TODO: 15.10.2019 Implement all other
  616.             }
  617.         }
  618.     }
  619. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!