001 002/* 003 * THIS FILE IS MACHINE_GENERATED. DO NOT EDIT. 004 * See InstructionFormats.template, InstructionFormatList.dat, 005 * OperatorList.dat, etc. 006 */ 007 008package org.jikesrvm.compilers.opt.ir; 009 010import org.jikesrvm.Configuration; 011import org.jikesrvm.compilers.opt.ir.operand.*; 012 013/** 014 * The Unary InstructionFormat class. 015 * 016 * The header comment for {@link Instruction} contains 017 * an explanation of the role of InstructionFormats in the 018 * opt compiler's IR. 019 */ 020@SuppressWarnings("unused") // Machine generated code is never 100% clean 021public final class Unary extends InstructionFormat { 022 /** 023 * InstructionFormat identification method for Unary. 024 * @param i an instruction 025 * @return <code>true</code> if the InstructionFormat of the argument 026 * instruction is Unary or <code>false</code> 027 * if it is not. 028 */ 029 public static boolean conforms(Instruction i) { 030 return conforms(i.operator()); 031 } 032 /** 033 * InstructionFormat identification method for Unary. 034 * @param o an instruction 035 * @return <code>true</code> if the InstructionFormat of the argument 036 * operator is Unary or <code>false</code> 037 * if it is not. 038 */ 039 public static boolean conforms(Operator o) { 040 return o.format == Unary_format; 041 } 042 043 /** 044 * Get the operand called Result from the 045 * argument instruction. Note that the returned operand 046 * will still point to its containing instruction. 047 * @param i the instruction to fetch the operand from 048 * @return the operand called Result 049 */ 050 public static RegisterOperand getResult(Instruction i) { 051 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 052 return (RegisterOperand) i.getOperand(0); 053 } 054 /** 055 * Get the operand called Result from the argument 056 * instruction clearing its instruction pointer. The returned 057 * operand will not point to any containing instruction. 058 * @param i the instruction to fetch the operand from 059 * @return the operand called Result 060 */ 061 public static RegisterOperand getClearResult(Instruction i) { 062 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 063 return (RegisterOperand) i.getClearOperand(0); 064 } 065 /** 066 * Set the operand called Result in the argument 067 * instruction to the argument operand. The operand will 068 * now point to the argument instruction as its containing 069 * instruction. 070 * @param i the instruction in which to store the operand 071 * @param Result the operand to store 072 */ 073 public static void setResult(Instruction i, RegisterOperand Result) { 074 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 075 i.putOperand(0, Result); 076 } 077 /** 078 * Return the index of the operand called Result 079 * in the argument instruction. 080 * @param i the instruction to access. 081 * @return the index of the operand called Result 082 * in the argument instruction 083 */ 084 public static int indexOfResult(Instruction i) { 085 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 086 return 0; 087 } 088 /** 089 * Does the argument instruction have a non-null 090 * operand named Result? 091 * @param i the instruction to access. 092 * @return <code>true</code> if the instruction has an non-null 093 * operand named Result or <code>false</code> 094 * if it does not. 095 */ 096 public static boolean hasResult(Instruction i) { 097 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 098 return i.getOperand(0) != null; 099 } 100 101 /** 102 * Get the operand called Val from the 103 * argument instruction. Note that the returned operand 104 * will still point to its containing instruction. 105 * @param i the instruction to fetch the operand from 106 * @return the operand called Val 107 */ 108 public static Operand getVal(Instruction i) { 109 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 110 return (Operand) i.getOperand(1); 111 } 112 /** 113 * Get the operand called Val from the argument 114 * instruction clearing its instruction pointer. The returned 115 * operand will not point to any containing instruction. 116 * @param i the instruction to fetch the operand from 117 * @return the operand called Val 118 */ 119 public static Operand getClearVal(Instruction i) { 120 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 121 return (Operand) i.getClearOperand(1); 122 } 123 /** 124 * Set the operand called Val in the argument 125 * instruction to the argument operand. The operand will 126 * now point to the argument instruction as its containing 127 * instruction. 128 * @param i the instruction in which to store the operand 129 * @param Val the operand to store 130 */ 131 public static void setVal(Instruction i, Operand Val) { 132 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 133 i.putOperand(1, Val); 134 } 135 /** 136 * Return the index of the operand called Val 137 * in the argument instruction. 138 * @param i the instruction to access. 139 * @return the index of the operand called Val 140 * in the argument instruction 141 */ 142 public static int indexOfVal(Instruction i) { 143 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 144 return 1; 145 } 146 /** 147 * Does the argument instruction have a non-null 148 * operand named Val? 149 * @param i the instruction to access. 150 * @return <code>true</code> if the instruction has an non-null 151 * operand named Val or <code>false</code> 152 * if it does not. 153 */ 154 public static boolean hasVal(Instruction i) { 155 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Unary"); 156 return i.getOperand(1) != null; 157 } 158 159 160 /** 161 * Create an instruction of the Unary instruction format. 162 * @param o the instruction's operator 163 * @param Result the instruction's Result operand 164 * @param Val the instruction's Val operand 165 * @return the newly created Unary instruction 166 */ 167 public static Instruction create(Operator o 168 , RegisterOperand Result 169 , Operand Val 170 ) 171 { 172 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Unary"); 173 Instruction i = Instruction.create(o, 5); 174 i.putOperand(0, Result); 175 i.putOperand(1, Val); 176 return i; 177 } 178 179 /** 180 * Mutate the argument instruction into an instruction of the 181 * Unary instruction format having the specified 182 * operator and operands. 183 * @param i the instruction to mutate 184 * @param o the instruction's operator 185 * @param Result the instruction's Result operand 186 * @param Val the instruction's Val operand 187 * @return the mutated instruction 188 */ 189 public static Instruction mutate(Instruction i, Operator o 190 , RegisterOperand Result 191 , Operand Val 192 ) 193 { 194 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Unary"); 195 i.changeOperatorTo(o); 196 i.putOperand(0, Result); 197 i.putOperand(1, Val); 198 return i; 199 } 200} 201