From ddfa57bd7be5341f78481521c223bd7df5c3337a Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 8 Apr 2009 05:41:03 +0000 Subject: Instcombine should not promote whole computation trees to "strange" integer types, unless they are already strange. This prevents it from turning the code produced by SROA into crazy libcalls and stuff that the code generator can't handle. In the attached example, the result was an i96 multiply that caused the x86 backend to assert. Note that if TargetData had an idea of what the legal types are for a target that this could be used to stop instcombine from introducing i64 muls, as Scott wanted. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68598 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Scalar/InstructionCombining.cpp | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) (limited to 'lib/Transforms') diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 4c39485b93..a2658b3e3f 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -7927,6 +7927,22 @@ Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) { return commonCastTransforms(CI); } +/// isSafeIntegerType - Return true if this is a basic integer type, not a crazy +/// type like i42. We don't want to introduce operations on random non-legal +/// integer types where they don't already exist in the code. In the future, +/// we should consider making this based off target-data, so that 32-bit targets +/// won't get i64 operations etc. +static bool isSafeIntegerType(const Type *Ty) { + switch (Ty->getPrimitiveSizeInBits()) { + case 8: + case 16: + case 32: + case 64: + return true; + default: + return false; + } +} /// Only the TRUNC, ZEXT, SEXT, and BITCAST can both operand and result as /// integer types. This function implements the common transforms for all those @@ -7956,6 +7972,10 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) { // Attempt to propagate the cast into the instruction for int->int casts. int NumCastsRemoved = 0; if (!isa(CI) && + // Only do this if the dest type is a simple type, don't convert the + // expression tree to something weird like i93 unless the source is also + // strange. + (isSafeIntegerType(DestTy) || !isSafeIntegerType(SrcI->getType())) && CanEvaluateInDifferentType(SrcI, cast(DestTy), CI.getOpcode(), NumCastsRemoved)) { // If this cast is a truncate, evaluting in a different type always -- cgit v1.2.3-70-g09d2