167 // a good trade-off between introduced new usages and
168 // eliminated nodes.
169 return null;
170 }
171 }
172 return duplicateModified(convertX.getValue(), convertY.getValue(), unorderedIsTrue, view);
173 }
174 }
175 }
176 return null;
177 }
178
179 protected LogicNode canonicalizeSymmetricConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
180 CanonicalCondition condition, Constant constant, ValueNode nonConstant, boolean mirrored, boolean unorderedIsTrue, NodeView view) {
181 if (nonConstant instanceof ConditionalNode) {
182 Condition realCondition = condition.asCondition();
183 if (mirrored) {
184 realCondition = realCondition.mirror();
185 }
186 return optimizeConditional(constant, (ConditionalNode) nonConstant, constantReflection, realCondition, unorderedIsTrue);
187 } else if (nonConstant instanceof NormalizeCompareNode) {
188 return optimizeNormalizeCompare(constantReflection, metaAccess, options, smallestCompareWidth, constant, (NormalizeCompareNode) nonConstant, mirrored, view);
189 } else if (nonConstant instanceof ConvertNode) {
190 ConvertNode convert = (ConvertNode) nonConstant;
191 boolean multiUsage = (convert.asNode().hasMoreThanOneUsage() && convert.getValue().hasExactlyOneUsage());
192 if ((convert instanceof ZeroExtendNode || convert instanceof SignExtendNode) && multiUsage) {
193 // Do not perform for zero or sign extend if it could introduce
194 // new live values.
195 return null;
196 }
197
198 boolean supported = true;
199 if (convert.getValue().stamp(view) instanceof IntegerStamp) {
200 IntegerStamp intStamp = (IntegerStamp) convert.getValue().stamp(view);
201 supported = smallestCompareWidth != null && intStamp.getBits() >= smallestCompareWidth;
202 }
203
204 if (supported) {
205 ConstantNode newConstant = canonicalConvertConstant(constantReflection, metaAccess, options, condition, convert, constant, view);
206 if (newConstant != null) {
207 if (mirrored) {
208 return duplicateModified(newConstant, convert.getValue(), unorderedIsTrue, view);
209 } else {
210 return duplicateModified(convert.getValue(), newConstant, unorderedIsTrue, view);
211 }
212 }
213 }
214 }
215
216 return null;
217 }
218
219 private static ConstantNode canonicalConvertConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, CanonicalCondition condition,
220 ConvertNode convert, Constant constant, NodeView view) {
221 if (convert.preservesOrder(condition, constant, constantReflection)) {
222 Constant reverseConverted = convert.reverse(constant, constantReflection);
223 if (reverseConverted != null && convert.convert(reverseConverted, constantReflection).equals(constant)) {
224 if (GeneratePIC.getValue(options)) {
225 // We always want uncompressed constants
226 return null;
227 }
228 return ConstantNode.forConstant(convert.getValue().stamp(view), reverseConverted, metaAccess);
229 }
230 }
231 return null;
232 }
233
234 @SuppressWarnings("unused")
235 protected LogicNode optimizeNormalizeCompare(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
236 Constant constant, NormalizeCompareNode normalizeNode, boolean mirrored, NodeView view) {
237 throw new PermanentBailoutException("NormalizeCompareNode connected to %s (%s %s %s)", this, constant, normalizeNode, mirrored);
238 }
239
240 private static LogicNode optimizeConditional(Constant constant, ConditionalNode conditionalNode, ConstantReflectionProvider constantReflection, Condition cond, boolean unorderedIsTrue) {
241 Constant trueConstant = conditionalNode.trueValue().asConstant();
242 Constant falseConstant = conditionalNode.falseValue().asConstant();
243
244 if (falseConstant != null && trueConstant != null && constantReflection != null) {
245 boolean trueResult = cond.foldCondition(trueConstant, constant, constantReflection, unorderedIsTrue);
246 boolean falseResult = cond.foldCondition(falseConstant, constant, constantReflection, unorderedIsTrue);
247
248 if (trueResult == falseResult) {
249 return LogicConstantNode.forBoolean(trueResult);
250 } else {
251 if (trueResult) {
252 assert falseResult == false;
253 return conditionalNode.condition();
254 } else {
255 assert falseResult == true;
256 return LogicNegationNode.create(conditionalNode.condition());
|
167 // a good trade-off between introduced new usages and
168 // eliminated nodes.
169 return null;
170 }
171 }
172 return duplicateModified(convertX.getValue(), convertY.getValue(), unorderedIsTrue, view);
173 }
174 }
175 }
176 return null;
177 }
178
179 protected LogicNode canonicalizeSymmetricConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
180 CanonicalCondition condition, Constant constant, ValueNode nonConstant, boolean mirrored, boolean unorderedIsTrue, NodeView view) {
181 if (nonConstant instanceof ConditionalNode) {
182 Condition realCondition = condition.asCondition();
183 if (mirrored) {
184 realCondition = realCondition.mirror();
185 }
186 return optimizeConditional(constant, (ConditionalNode) nonConstant, constantReflection, realCondition, unorderedIsTrue);
187 } else if (nonConstant instanceof AbstractNormalizeCompareNode) {
188 return optimizeNormalizeCompare(constantReflection, metaAccess, options, smallestCompareWidth, constant, (AbstractNormalizeCompareNode) nonConstant, mirrored, view);
189 } else if (nonConstant instanceof ConvertNode) {
190 ConvertNode convert = (ConvertNode) nonConstant;
191 boolean multiUsage = (convert.asNode().hasMoreThanOneUsage() && convert.getValue().hasExactlyOneUsage());
192 if (convert instanceof IntegerConvertNode && multiUsage) {
193 // Do not perform for integer convers if it could introduce
194 // new live values.
195 return null;
196 }
197
198 if (convert instanceof NarrowNode) {
199 NarrowNode narrowNode = (NarrowNode) convert;
200 if (narrowNode.getInputBits() > 32 && !constant.isDefaultForKind()) {
201 // Avoid large integer constants.
202 return null;
203 }
204 }
205
206 boolean supported = true;
207 if (convert.getValue().stamp(view) instanceof IntegerStamp) {
208 IntegerStamp intStamp = (IntegerStamp) convert.getValue().stamp(view);
209 supported = smallestCompareWidth != null && intStamp.getBits() >= smallestCompareWidth;
210 }
211
212 if (supported) {
213 ConstantNode newConstant = canonicalConvertConstant(constantReflection, metaAccess, options, condition, convert, constant, view);
214 if (newConstant != null) {
215 if (mirrored) {
216 return duplicateModified(newConstant, convert.getValue(), unorderedIsTrue, view);
217 } else {
218 return duplicateModified(convert.getValue(), newConstant, unorderedIsTrue, view);
219 }
220 }
221 }
222 }
223
224 return null;
225 }
226
227 private static ConstantNode canonicalConvertConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, CanonicalCondition condition,
228 ConvertNode convert, Constant constant, NodeView view) {
229 if (convert.preservesOrder(condition, constant, constantReflection)) {
230 Constant reverseConverted = convert.reverse(constant, constantReflection);
231 if (reverseConverted != null && convert.convert(reverseConverted, constantReflection).equals(constant)) {
232 if (GeneratePIC.getValue(options)) {
233 // We always want uncompressed constants
234 return null;
235 }
236 return ConstantNode.forConstant(convert.getValue().stamp(view), reverseConverted, metaAccess);
237 }
238 }
239 return null;
240 }
241
242 @SuppressWarnings("unused")
243 protected LogicNode optimizeNormalizeCompare(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
244 Constant constant, AbstractNormalizeCompareNode normalizeNode, boolean mirrored, NodeView view) {
245 throw new PermanentBailoutException("NormalizeCompareNode connected to %s (%s %s %s)", this, constant, normalizeNode, mirrored);
246 }
247
248 private static LogicNode optimizeConditional(Constant constant, ConditionalNode conditionalNode, ConstantReflectionProvider constantReflection, Condition cond, boolean unorderedIsTrue) {
249 Constant trueConstant = conditionalNode.trueValue().asConstant();
250 Constant falseConstant = conditionalNode.falseValue().asConstant();
251
252 if (falseConstant != null && trueConstant != null && constantReflection != null) {
253 boolean trueResult = cond.foldCondition(trueConstant, constant, constantReflection, unorderedIsTrue);
254 boolean falseResult = cond.foldCondition(falseConstant, constant, constantReflection, unorderedIsTrue);
255
256 if (trueResult == falseResult) {
257 return LogicConstantNode.forBoolean(trueResult);
258 } else {
259 if (trueResult) {
260 assert falseResult == false;
261 return conditionalNode.condition();
262 } else {
263 assert falseResult == true;
264 return LogicNegationNode.create(conditionalNode.condition());
|