1310968cbbb564c4141d4bd418a746e8103560222Chris Lattner//===-- TargetLowering.cpp - Implement the TargetLowering class -----------===// 2f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 3310968cbbb564c4141d4bd418a746e8103560222Chris Lattner// The LLVM Compiler Infrastructure 4310968cbbb564c4141d4bd418a746e8103560222Chris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 8310968cbbb564c4141d4bd418a746e8103560222Chris Lattner//===----------------------------------------------------------------------===// 9310968cbbb564c4141d4bd418a746e8103560222Chris Lattner// 10310968cbbb564c4141d4bd418a746e8103560222Chris Lattner// This implements the TargetLowering class. 11310968cbbb564c4141d4bd418a746e8103560222Chris Lattner// 12310968cbbb564c4141d4bd418a746e8103560222Chris Lattner//===----------------------------------------------------------------------===// 13310968cbbb564c4141d4bd418a746e8103560222Chris Lattner 14310968cbbb564c4141d4bd418a746e8103560222Chris Lattner#include "llvm/Target/TargetLowering.h" 15af76e592c7f9deff0e55c13dbb4a34f07f1c7f64Chris Lattner#include "llvm/MC/MCAsmInfo.h" 16beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner#include "llvm/MC/MCExpr.h" 1707000c6f01d8f57170f2d4c77a86d934bdc5c696Owen Anderson#include "llvm/Target/TargetData.h" 18f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner#include "llvm/Target/TargetLoweringObjectFile.h" 19310968cbbb564c4141d4bd418a746e8103560222Chris Lattner#include "llvm/Target/TargetMachine.h" 206f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman#include "llvm/Target/TargetRegisterInfo.h" 21707e0184233f27e0e9f9aee0309f2daab8cfe7f8Dan Gohman#include "llvm/GlobalVariable.h" 22dc879296090a738c66968f5eec77db65d7e03623Chris Lattner#include "llvm/DerivedTypes.h" 2384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman#include "llvm/CodeGen/Analysis.h" 24ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng#include "llvm/CodeGen/MachineFrameInfo.h" 25071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner#include "llvm/CodeGen/MachineJumpTableInfo.h" 26589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 27310968cbbb564c4141d4bd418a746e8103560222Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 28e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen#include "llvm/ADT/BitVector.h" 29718cb665ca6ce2bc4d8e8479f46a45db91b49f86Owen Anderson#include "llvm/ADT/STLExtras.h" 30b6fbec3a546fd04bb2e79040db2436b0bd629162Nadav Rotem#include "llvm/Support/CommandLine.h" 31c25e7581b9b8088910da31702d4ca21c4734c6d7Torok Edwin#include "llvm/Support/ErrorHandling.h" 32c6fd6cd65c88ef1f11da43c11be0152cb69013a7Chris Lattner#include "llvm/Support/MathExtras.h" 33476b242fe7a61e5f9ac6214b0bc5c680d24f152eNick Lewycky#include <cctype> 34310968cbbb564c4141d4bd418a746e8103560222Chris Lattnerusing namespace llvm; 35310968cbbb564c4141d4bd418a746e8103560222Chris Lattner 3656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng/// InitLibcallNames - Set default libcall names. 3756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng/// 3879cca507fe51aa8af7a9006b380977c61b6f3feaEvan Chengstatic void InitLibcallNames(const char **Names) { 39c31642f7af64bfaed36064b52a5cb2366fd01064Anton Korobeynikov Names[RTLIB::SHL_I16] = "__ashlhi3"; 4056966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SHL_I32] = "__ashlsi3"; 4156966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SHL_I64] = "__ashldi3"; 42dddc6291fb5274282a20d5923b50535d456d34a4Duncan Sands Names[RTLIB::SHL_I128] = "__ashlti3"; 43c31642f7af64bfaed36064b52a5cb2366fd01064Anton Korobeynikov Names[RTLIB::SRL_I16] = "__lshrhi3"; 4456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SRL_I32] = "__lshrsi3"; 4556966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SRL_I64] = "__lshrdi3"; 46dddc6291fb5274282a20d5923b50535d456d34a4Duncan Sands Names[RTLIB::SRL_I128] = "__lshrti3"; 47c31642f7af64bfaed36064b52a5cb2366fd01064Anton Korobeynikov Names[RTLIB::SRA_I16] = "__ashrhi3"; 4856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SRA_I32] = "__ashrsi3"; 4956966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SRA_I64] = "__ashrdi3"; 50dddc6291fb5274282a20d5923b50535d456d34a4Duncan Sands Names[RTLIB::SRA_I128] = "__ashrti3"; 518983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov Names[RTLIB::MUL_I8] = "__mulqi3"; 52c31642f7af64bfaed36064b52a5cb2366fd01064Anton Korobeynikov Names[RTLIB::MUL_I16] = "__mulhi3"; 5356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::MUL_I32] = "__mulsi3"; 5456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::MUL_I64] = "__muldi3"; 555ac319ac7125b009adddcc49294d2e040c4a91e5Duncan Sands Names[RTLIB::MUL_I128] = "__multi3"; 56362fee90b9a1d64ac091755466caf6a94ade22ebEric Christopher Names[RTLIB::MULO_I32] = "__mulosi4"; 57362fee90b9a1d64ac091755466caf6a94ade22ebEric Christopher Names[RTLIB::MULO_I64] = "__mulodi4"; 58362fee90b9a1d64ac091755466caf6a94ade22ebEric Christopher Names[RTLIB::MULO_I128] = "__muloti4"; 598983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov Names[RTLIB::SDIV_I8] = "__divqi3"; 60813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov Names[RTLIB::SDIV_I16] = "__divhi3"; 6156966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SDIV_I32] = "__divsi3"; 6256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SDIV_I64] = "__divdi3"; 635ac319ac7125b009adddcc49294d2e040c4a91e5Duncan Sands Names[RTLIB::SDIV_I128] = "__divti3"; 648983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov Names[RTLIB::UDIV_I8] = "__udivqi3"; 65fb3f84fe16219467cef4ed181530e846177cb4dfAnton Korobeynikov Names[RTLIB::UDIV_I16] = "__udivhi3"; 6656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UDIV_I32] = "__udivsi3"; 6756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UDIV_I64] = "__udivdi3"; 685ac319ac7125b009adddcc49294d2e040c4a91e5Duncan Sands Names[RTLIB::UDIV_I128] = "__udivti3"; 698983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov Names[RTLIB::SREM_I8] = "__modqi3"; 70813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov Names[RTLIB::SREM_I16] = "__modhi3"; 7156966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SREM_I32] = "__modsi3"; 7256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SREM_I64] = "__moddi3"; 735ac319ac7125b009adddcc49294d2e040c4a91e5Duncan Sands Names[RTLIB::SREM_I128] = "__modti3"; 748983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov Names[RTLIB::UREM_I8] = "__umodqi3"; 759fe9c8ec7d7d1e260927cb66e91d5e69db8a6febAnton Korobeynikov Names[RTLIB::UREM_I16] = "__umodhi3"; 7656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UREM_I32] = "__umodsi3"; 7756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UREM_I64] = "__umoddi3"; 785ac319ac7125b009adddcc49294d2e040c4a91e5Duncan Sands Names[RTLIB::UREM_I128] = "__umodti3"; 798e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 808e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng // These are generally not available. 818e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::SDIVREM_I8] = 0; 828e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::SDIVREM_I16] = 0; 838e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::SDIVREM_I32] = 0; 848e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::SDIVREM_I64] = 0; 858e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::SDIVREM_I128] = 0; 868e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::UDIVREM_I8] = 0; 878e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::UDIVREM_I16] = 0; 888e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::UDIVREM_I32] = 0; 898e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::UDIVREM_I64] = 0; 908e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Names[RTLIB::UDIVREM_I128] = 0; 918e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 9256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::NEG_I32] = "__negsi2"; 9356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::NEG_I64] = "__negdi2"; 9456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::ADD_F32] = "__addsf3"; 9556966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::ADD_F64] = "__adddf3"; 96007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::ADD_F80] = "__addxf3"; 97161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::ADD_PPCF128] = "__gcc_qadd"; 9856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SUB_F32] = "__subsf3"; 9956966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SUB_F64] = "__subdf3"; 100007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::SUB_F80] = "__subxf3"; 101161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::SUB_PPCF128] = "__gcc_qsub"; 10256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::MUL_F32] = "__mulsf3"; 10356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::MUL_F64] = "__muldf3"; 104007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::MUL_F80] = "__mulxf3"; 105161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::MUL_PPCF128] = "__gcc_qmul"; 10656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::DIV_F32] = "__divsf3"; 10756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::DIV_F64] = "__divdf3"; 108007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::DIV_F80] = "__divxf3"; 109161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::DIV_PPCF128] = "__gcc_qdiv"; 11056966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::REM_F32] = "fmodf"; 11156966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::REM_F64] = "fmod"; 112007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::REM_F80] = "fmodl"; 113161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::REM_PPCF128] = "fmodl"; 11433390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich Names[RTLIB::FMA_F32] = "fmaf"; 11533390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich Names[RTLIB::FMA_F64] = "fma"; 11633390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich Names[RTLIB::FMA_F80] = "fmal"; 11733390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich Names[RTLIB::FMA_PPCF128] = "fmal"; 11856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::POWI_F32] = "__powisf2"; 11956966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::POWI_F64] = "__powidf2"; 120161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::POWI_F80] = "__powixf2"; 121161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::POWI_PPCF128] = "__powitf2"; 12256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SQRT_F32] = "sqrtf"; 12356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SQRT_F64] = "sqrt"; 124161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::SQRT_F80] = "sqrtl"; 125161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::SQRT_PPCF128] = "sqrtl"; 1267794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG_F32] = "logf"; 1277794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG_F64] = "log"; 1287794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG_F80] = "logl"; 1297794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG_PPCF128] = "logl"; 1307794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG2_F32] = "log2f"; 1317794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG2_F64] = "log2"; 1327794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG2_F80] = "log2l"; 1337794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG2_PPCF128] = "log2l"; 1347794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG10_F32] = "log10f"; 1357794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG10_F64] = "log10"; 1367794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG10_F80] = "log10l"; 1377794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::LOG10_PPCF128] = "log10l"; 1387794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP_F32] = "expf"; 1397794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP_F64] = "exp"; 1407794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP_F80] = "expl"; 1417794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP_PPCF128] = "expl"; 1427794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP2_F32] = "exp2f"; 1437794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP2_F64] = "exp2"; 1447794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP2_F80] = "exp2l"; 1457794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen Names[RTLIB::EXP2_PPCF128] = "exp2l"; 14656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SIN_F32] = "sinf"; 14756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SIN_F64] = "sin"; 148007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::SIN_F80] = "sinl"; 149007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::SIN_PPCF128] = "sinl"; 15056966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::COS_F32] = "cosf"; 15156966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::COS_F64] = "cos"; 152007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::COS_F80] = "cosl"; 153007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands Names[RTLIB::COS_PPCF128] = "cosl"; 154e54be104180d81b61c5fcc29ccb7960f9b78476eDan Gohman Names[RTLIB::POW_F32] = "powf"; 155e54be104180d81b61c5fcc29ccb7960f9b78476eDan Gohman Names[RTLIB::POW_F64] = "pow"; 156e54be104180d81b61c5fcc29ccb7960f9b78476eDan Gohman Names[RTLIB::POW_F80] = "powl"; 157e54be104180d81b61c5fcc29ccb7960f9b78476eDan Gohman Names[RTLIB::POW_PPCF128] = "powl"; 1582bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::CEIL_F32] = "ceilf"; 1592bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::CEIL_F64] = "ceil"; 1602bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::CEIL_F80] = "ceill"; 1612bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::CEIL_PPCF128] = "ceill"; 1622bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::TRUNC_F32] = "truncf"; 1632bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::TRUNC_F64] = "trunc"; 1642bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::TRUNC_F80] = "truncl"; 1652bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::TRUNC_PPCF128] = "truncl"; 1662bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::RINT_F32] = "rintf"; 1672bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::RINT_F64] = "rint"; 1682bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::RINT_F80] = "rintl"; 1692bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::RINT_PPCF128] = "rintl"; 1702bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::NEARBYINT_F32] = "nearbyintf"; 1712bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::NEARBYINT_F64] = "nearbyint"; 1722bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::NEARBYINT_F80] = "nearbyintl"; 1732bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::NEARBYINT_PPCF128] = "nearbyintl"; 1742bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::FLOOR_F32] = "floorf"; 1752bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::FLOOR_F64] = "floor"; 1762bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::FLOOR_F80] = "floorl"; 1772bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman Names[RTLIB::FLOOR_PPCF128] = "floorl"; 178d2c817eff1d158398fb0a620fa762bf95207922fDuncan Sands Names[RTLIB::COPYSIGN_F32] = "copysignf"; 179d2c817eff1d158398fb0a620fa762bf95207922fDuncan Sands Names[RTLIB::COPYSIGN_F64] = "copysign"; 180d2c817eff1d158398fb0a620fa762bf95207922fDuncan Sands Names[RTLIB::COPYSIGN_F80] = "copysignl"; 181d2c817eff1d158398fb0a620fa762bf95207922fDuncan Sands Names[RTLIB::COPYSIGN_PPCF128] = "copysignl"; 18256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPEXT_F32_F64] = "__extendsfdf2"; 183927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov Names[RTLIB::FPEXT_F16_F32] = "__gnu_h2f_ieee"; 184927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov Names[RTLIB::FPROUND_F32_F16] = "__gnu_f2h_ieee"; 18556966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPROUND_F64_F32] = "__truncdfsf2"; 186e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes Names[RTLIB::FPROUND_F80_F32] = "__truncxfsf2"; 187e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes Names[RTLIB::FPROUND_PPCF128_F32] = "__trunctfsf2"; 188e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes Names[RTLIB::FPROUND_F80_F64] = "__truncxfdf2"; 189e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes Names[RTLIB::FPROUND_PPCF128_F64] = "__trunctfdf2"; 190de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOSINT_F32_I8] = "__fixsfqi"; 191de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOSINT_F32_I16] = "__fixsfhi"; 19256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOSINT_F32_I32] = "__fixsfsi"; 19356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOSINT_F32_I64] = "__fixsfdi"; 194a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOSINT_F32_I128] = "__fixsfti"; 195de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOSINT_F64_I8] = "__fixdfqi"; 196de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOSINT_F64_I16] = "__fixdfhi"; 19756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOSINT_F64_I32] = "__fixdfsi"; 19856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOSINT_F64_I64] = "__fixdfdi"; 199a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOSINT_F64_I128] = "__fixdfti"; 200be1ad4de2900451626c8d4ace07b9ea16099ea1dDuncan Sands Names[RTLIB::FPTOSINT_F80_I32] = "__fixxfsi"; 201161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::FPTOSINT_F80_I64] = "__fixxfdi"; 202a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOSINT_F80_I128] = "__fixxfti"; 203041cde26eaf4ef6171ff1a44aeedd08d7a1cba6cDuncan Sands Names[RTLIB::FPTOSINT_PPCF128_I32] = "__fixtfsi"; 204161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::FPTOSINT_PPCF128_I64] = "__fixtfdi"; 205a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOSINT_PPCF128_I128] = "__fixtfti"; 206de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOUINT_F32_I8] = "__fixunssfqi"; 207de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOUINT_F32_I16] = "__fixunssfhi"; 20856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOUINT_F32_I32] = "__fixunssfsi"; 20956966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOUINT_F32_I64] = "__fixunssfdi"; 210a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOUINT_F32_I128] = "__fixunssfti"; 211de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOUINT_F64_I8] = "__fixunsdfqi"; 212de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov Names[RTLIB::FPTOUINT_F64_I16] = "__fixunsdfhi"; 21356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOUINT_F64_I32] = "__fixunsdfsi"; 21456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::FPTOUINT_F64_I64] = "__fixunsdfdi"; 215a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOUINT_F64_I128] = "__fixunsdfti"; 216161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::FPTOUINT_F80_I32] = "__fixunsxfsi"; 217161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::FPTOUINT_F80_I64] = "__fixunsxfdi"; 218a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOUINT_F80_I128] = "__fixunsxfti"; 219041cde26eaf4ef6171ff1a44aeedd08d7a1cba6cDuncan Sands Names[RTLIB::FPTOUINT_PPCF128_I32] = "__fixunstfsi"; 220161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::FPTOUINT_PPCF128_I64] = "__fixunstfdi"; 221a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman Names[RTLIB::FPTOUINT_PPCF128_I128] = "__fixunstfti"; 22256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SINTTOFP_I32_F32] = "__floatsisf"; 22356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SINTTOFP_I32_F64] = "__floatsidf"; 2249bed0f58eb7f5e9e22d062f3880a5fabfdd0dfddDuncan Sands Names[RTLIB::SINTTOFP_I32_F80] = "__floatsixf"; 2259bed0f58eb7f5e9e22d062f3880a5fabfdd0dfddDuncan Sands Names[RTLIB::SINTTOFP_I32_PPCF128] = "__floatsitf"; 22656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SINTTOFP_I64_F32] = "__floatdisf"; 22756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::SINTTOFP_I64_F64] = "__floatdidf"; 228161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::SINTTOFP_I64_F80] = "__floatdixf"; 229161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen Names[RTLIB::SINTTOFP_I64_PPCF128] = "__floatditf"; 230d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman Names[RTLIB::SINTTOFP_I128_F32] = "__floattisf"; 231d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman Names[RTLIB::SINTTOFP_I128_F64] = "__floattidf"; 232d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman Names[RTLIB::SINTTOFP_I128_F80] = "__floattixf"; 233d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman Names[RTLIB::SINTTOFP_I128_PPCF128] = "__floattitf"; 23456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UINTTOFP_I32_F32] = "__floatunsisf"; 23556966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UINTTOFP_I32_F64] = "__floatunsidf"; 236ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I32_F80] = "__floatunsixf"; 237ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I32_PPCF128] = "__floatunsitf"; 23856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UINTTOFP_I64_F32] = "__floatundisf"; 23956966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UINTTOFP_I64_F64] = "__floatundidf"; 240ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I64_F80] = "__floatundixf"; 241ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I64_PPCF128] = "__floatunditf"; 242ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I128_F32] = "__floatuntisf"; 243ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I128_F64] = "__floatuntidf"; 244ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I128_F80] = "__floatuntixf"; 245ac6cecec189ba9689c42543c3106c02b96d788daDuncan Sands Names[RTLIB::UINTTOFP_I128_PPCF128] = "__floatuntitf"; 24656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OEQ_F32] = "__eqsf2"; 24756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OEQ_F64] = "__eqdf2"; 24856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UNE_F32] = "__nesf2"; 24956966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UNE_F64] = "__nedf2"; 25056966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OGE_F32] = "__gesf2"; 25156966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OGE_F64] = "__gedf2"; 25256966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OLT_F32] = "__ltsf2"; 25356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OLT_F64] = "__ltdf2"; 25456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OLE_F32] = "__lesf2"; 25556966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OLE_F64] = "__ledf2"; 25656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OGT_F32] = "__gtsf2"; 25756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::OGT_F64] = "__gtdf2"; 25856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UO_F32] = "__unordsf2"; 25956966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng Names[RTLIB::UO_F64] = "__unorddf2"; 260d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng Names[RTLIB::O_F32] = "__unordsf2"; 261d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng Names[RTLIB::O_F64] = "__unorddf2"; 262a114baa5bf0d70aed8b8cf576a864005c0d6a128Sanjiv Gupta Names[RTLIB::MEMCPY] = "memcpy"; 263a114baa5bf0d70aed8b8cf576a864005c0d6a128Sanjiv Gupta Names[RTLIB::MEMMOVE] = "memmove"; 264a114baa5bf0d70aed8b8cf576a864005c0d6a128Sanjiv Gupta Names[RTLIB::MEMSET] = "memset"; 265b0f1e1780c736c62fb99e5824825d2a60a53b53bDuncan Sands Names[RTLIB::UNWIND_RESUME] = "_Unwind_Resume"; 266e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_1] = "__sync_val_compare_and_swap_1"; 267e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_2] = "__sync_val_compare_and_swap_2"; 268e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_4] = "__sync_val_compare_and_swap_4"; 269e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_8] = "__sync_val_compare_and_swap_8"; 270ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach Names[RTLIB::SYNC_LOCK_TEST_AND_SET_1] = "__sync_lock_test_and_set_1"; 271ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach Names[RTLIB::SYNC_LOCK_TEST_AND_SET_2] = "__sync_lock_test_and_set_2"; 272ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach Names[RTLIB::SYNC_LOCK_TEST_AND_SET_4] = "__sync_lock_test_and_set_4"; 273ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach Names[RTLIB::SYNC_LOCK_TEST_AND_SET_8] = "__sync_lock_test_and_set_8"; 274e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_ADD_1] = "__sync_fetch_and_add_1"; 275e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_ADD_2] = "__sync_fetch_and_add_2"; 276e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_ADD_4] = "__sync_fetch_and_add_4"; 277e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_ADD_8] = "__sync_fetch_and_add_8"; 278e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_SUB_1] = "__sync_fetch_and_sub_1"; 279e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_SUB_2] = "__sync_fetch_and_sub_2"; 280e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_SUB_4] = "__sync_fetch_and_sub_4"; 281e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_SUB_8] = "__sync_fetch_and_sub_8"; 282e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_AND_1] = "__sync_fetch_and_and_1"; 283e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_AND_2] = "__sync_fetch_and_and_2"; 284e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_AND_4] = "__sync_fetch_and_and_4"; 285e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_AND_8] = "__sync_fetch_and_and_8"; 286e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_OR_1] = "__sync_fetch_and_or_1"; 287e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_OR_2] = "__sync_fetch_and_or_2"; 288e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_OR_4] = "__sync_fetch_and_or_4"; 289e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_OR_8] = "__sync_fetch_and_or_8"; 290e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_XOR_1] = "__sync_fetch_and_xor_1"; 291e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_XOR_2] = "__sync_fetch_and_xor_2"; 292312b7c950a27f72a811b3fdbed26e2e08eb20c31Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_XOR_4] = "__sync_fetch_and_xor_4"; 293e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_XOR_8] = "__sync_fetch_and_xor_8"; 294e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_NAND_1] = "__sync_fetch_and_nand_1"; 295e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_NAND_2] = "__sync_fetch_and_nand_2"; 296e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_NAND_4] = "__sync_fetch_and_nand_4"; 297e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Names[RTLIB::SYNC_FETCH_AND_NAND_8] = "__sync_fetch_and_nand_8"; 298d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng} 299d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng 30072977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov/// InitLibcallCallingConvs - Set default libcall CallingConvs. 30172977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov/// 30272977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikovstatic void InitLibcallCallingConvs(CallingConv::ID *CCs) { 30372977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov for (int i = 0; i < RTLIB::UNKNOWN_LIBCALL; ++i) { 30472977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov CCs[i] = CallingConv::C; 30572977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov } 30672977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov} 30772977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov 308b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// getFPEXT - Return the FPEXT_*_* value for the given types, or 309b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// UNKNOWN_LIBCALL if there is none. 310e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonRTLIB::Libcall RTLIB::getFPEXT(EVT OpVT, EVT RetVT) { 311825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::f32) { 312825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f64) 313b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPEXT_F32_F64; 314b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands } 315927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov 316b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UNKNOWN_LIBCALL; 317b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands} 318b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands 319b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// getFPROUND - Return the FPROUND_*_* value for the given types, or 320b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// UNKNOWN_LIBCALL if there is none. 321e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonRTLIB::Libcall RTLIB::getFPROUND(EVT OpVT, EVT RetVT) { 322825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f32) { 323825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::f64) 324b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPROUND_F64_F32; 325825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::f80) 326e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes return FPROUND_F80_F32; 327825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::ppcf128) 328e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes return FPROUND_PPCF128_F32; 329825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (RetVT == MVT::f64) { 330825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::f80) 331e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes return FPROUND_F80_F64; 332825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::ppcf128) 333e36bfe678df09f46e1eac60b15105c1ccd2c5382Bruno Cardoso Lopes return FPROUND_PPCF128_F64; 334b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands } 335927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov 336b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UNKNOWN_LIBCALL; 337b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands} 338b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands 339b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// getFPTOSINT - Return the FPTOSINT_*_* value for the given types, or 340b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// UNKNOWN_LIBCALL if there is none. 341e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonRTLIB::Libcall RTLIB::getFPTOSINT(EVT OpVT, EVT RetVT) { 342825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::f32) { 343825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i8) 3448aa207ee306b6a5ce753511a5f811fc1cd2468e2Sanjiv Gupta return FPTOSINT_F32_I8; 345825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i16) 3468aa207ee306b6a5ce753511a5f811fc1cd2468e2Sanjiv Gupta return FPTOSINT_F32_I16; 347825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 348b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F32_I32; 349825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 350b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F32_I64; 351825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 352b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F32_I128; 353825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::f64) { 354de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov if (RetVT == MVT::i8) 355de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov return FPTOSINT_F64_I8; 356de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov if (RetVT == MVT::i16) 357de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov return FPTOSINT_F64_I16; 358825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 359b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F64_I32; 360825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 361b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F64_I64; 362825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 363b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F64_I128; 364825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::f80) { 365825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 366b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F80_I32; 367825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 368b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F80_I64; 369825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 370b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_F80_I128; 371825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::ppcf128) { 372825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 373b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_PPCF128_I32; 374825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 375b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_PPCF128_I64; 376825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 377b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOSINT_PPCF128_I128; 378b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands } 379b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UNKNOWN_LIBCALL; 380b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands} 381b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands 382b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// getFPTOUINT - Return the FPTOUINT_*_* value for the given types, or 383b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// UNKNOWN_LIBCALL if there is none. 384e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonRTLIB::Libcall RTLIB::getFPTOUINT(EVT OpVT, EVT RetVT) { 385825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::f32) { 386825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i8) 3878aa207ee306b6a5ce753511a5f811fc1cd2468e2Sanjiv Gupta return FPTOUINT_F32_I8; 388825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i16) 3898aa207ee306b6a5ce753511a5f811fc1cd2468e2Sanjiv Gupta return FPTOUINT_F32_I16; 390825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 391b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F32_I32; 392825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 393b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F32_I64; 394825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 395b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F32_I128; 396825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::f64) { 397de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov if (RetVT == MVT::i8) 398de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov return FPTOUINT_F64_I8; 399de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov if (RetVT == MVT::i16) 400de0118c324a3fb8b0b5afa8e46996d9b81666bfdAnton Korobeynikov return FPTOUINT_F64_I16; 401825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 402b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F64_I32; 403825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 404b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F64_I64; 405825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 406b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F64_I128; 407825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::f80) { 408825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 409b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F80_I32; 410825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 411b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F80_I64; 412825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 413b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_F80_I128; 414825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::ppcf128) { 415825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i32) 416b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_PPCF128_I32; 417825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i64) 418b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_PPCF128_I64; 419825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::i128) 420b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return FPTOUINT_PPCF128_I128; 421b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands } 422b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UNKNOWN_LIBCALL; 423b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands} 424b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands 425b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// getSINTTOFP - Return the SINTTOFP_*_* value for the given types, or 426b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// UNKNOWN_LIBCALL if there is none. 427e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonRTLIB::Libcall RTLIB::getSINTTOFP(EVT OpVT, EVT RetVT) { 428825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::i32) { 429825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f32) 430b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I32_F32; 431825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f64) 432b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I32_F64; 433825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f80) 434b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I32_F80; 435825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::ppcf128) 436b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I32_PPCF128; 437825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::i64) { 438825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f32) 439b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I64_F32; 440825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f64) 441b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I64_F64; 442825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f80) 443b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I64_F80; 444825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::ppcf128) 445b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I64_PPCF128; 446825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::i128) { 447825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f32) 448b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I128_F32; 449825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f64) 450b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I128_F64; 451825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f80) 452b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I128_F80; 453825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::ppcf128) 454b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return SINTTOFP_I128_PPCF128; 455b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands } 456b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UNKNOWN_LIBCALL; 457b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands} 458b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands 459b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// getUINTTOFP - Return the UINTTOFP_*_* value for the given types, or 460b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands/// UNKNOWN_LIBCALL if there is none. 461e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonRTLIB::Libcall RTLIB::getUINTTOFP(EVT OpVT, EVT RetVT) { 462825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (OpVT == MVT::i32) { 463825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f32) 464b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I32_F32; 465825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f64) 466b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I32_F64; 467825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f80) 468b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I32_F80; 469825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::ppcf128) 470b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I32_PPCF128; 471825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::i64) { 472825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f32) 473b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I64_F32; 474825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f64) 475b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I64_F64; 476825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f80) 477b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I64_F80; 478825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::ppcf128) 479b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I64_PPCF128; 480825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (OpVT == MVT::i128) { 481825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (RetVT == MVT::f32) 482b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I128_F32; 483825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f64) 484b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I128_F64; 485825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::f80) 486b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I128_F80; 487825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (RetVT == MVT::ppcf128) 488b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UINTTOFP_I128_PPCF128; 489b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands } 490b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands return UNKNOWN_LIBCALL; 491b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands} 492b2ff885aaed8f9b033b16ca78d645650efc32433Duncan Sands 493d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng/// InitCmpLibcallCCs - Set default comparison libcall CC. 494d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng/// 495d385fd62cb43435b3ad70d789198d34bf148e579Evan Chengstatic void InitCmpLibcallCCs(ISD::CondCode *CCs) { 496d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng memset(CCs, ISD::SETCC_INVALID, sizeof(ISD::CondCode)*RTLIB::UNKNOWN_LIBCALL); 497d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OEQ_F32] = ISD::SETEQ; 498d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OEQ_F64] = ISD::SETEQ; 499d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::UNE_F32] = ISD::SETNE; 500d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::UNE_F64] = ISD::SETNE; 501d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OGE_F32] = ISD::SETGE; 502d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OGE_F64] = ISD::SETGE; 503d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OLT_F32] = ISD::SETLT; 504d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OLT_F64] = ISD::SETLT; 505d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OLE_F32] = ISD::SETLE; 506d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OLE_F64] = ISD::SETLE; 507d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OGT_F32] = ISD::SETGT; 508d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::OGT_F64] = ISD::SETGT; 509d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::UO_F32] = ISD::SETNE; 510d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::UO_F64] = ISD::SETNE; 511d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::O_F32] = ISD::SETEQ; 512d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng CCs[RTLIB::O_F64] = ISD::SETEQ; 51356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng} 51456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng 515f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner/// NOTE: The constructor takes ownership of TLOF. 516f0757b0edc1ef3d1998485d3f74cadaa3f7180a0Dan GohmanTargetLowering::TargetLowering(const TargetMachine &tm, 517f0757b0edc1ef3d1998485d3f74cadaa3f7180a0Dan Gohman const TargetLoweringObjectFile *tlof) 518fcb2c3cf5e8ee421fd3a5639cc4a33036e9a614eNadav Rotem : TM(tm), TD(TM.getTargetData()), TLOF(*tlof) { 519cba82f9339566cef76ecb062980e40913e6ccc23Chris Lattner // All operations default to being supported. 520cba82f9339566cef76ecb062980e40913e6ccc23Chris Lattner memset(OpActions, 0, sizeof(OpActions)); 5210329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng memset(LoadExtActions, 0, sizeof(LoadExtActions)); 522ddf89566a93081cb230bb9406a72ab2d3eada4a7Chris Lattner memset(TruncStoreActions, 0, sizeof(TruncStoreActions)); 523c9133f97720a36218ddfa6bfbf36ba6e22c011f7Chris Lattner memset(IndexedModeActions, 0, sizeof(IndexedModeActions)); 5247f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng memset(CondCodeActions, 0, sizeof(CondCodeActions)); 52593f81e2822aa67337f629398c81bc2844ef9400aDan Gohman 5261a3048bb8e0f3de0b4e56704c15c556c71565f4bChris Lattner // Set default actions for various operations. 527825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson for (unsigned VT = 0; VT != (unsigned)MVT::LAST_VALUETYPE; ++VT) { 5281a3048bb8e0f3de0b4e56704c15c556c71565f4bChris Lattner // Default all indexed load / store to expand. 5295ff839fbabe8b1d26cf4db5c541eb5d7942c25d6Evan Cheng for (unsigned IM = (unsigned)ISD::PRE_INC; 5305ff839fbabe8b1d26cf4db5c541eb5d7942c25d6Evan Cheng IM != (unsigned)ISD::LAST_INDEXED_MODE; ++IM) { 531825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setIndexedLoadAction(IM, (MVT::SimpleValueType)VT, Expand); 532825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setIndexedStoreAction(IM, (MVT::SimpleValueType)VT, Expand); 5335ff839fbabe8b1d26cf4db5c541eb5d7942c25d6Evan Cheng } 534bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 5351a3048bb8e0f3de0b4e56704c15c556c71565f4bChris Lattner // These operations default to expand. 536825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setOperationAction(ISD::FGETSIGN, (MVT::SimpleValueType)VT, Expand); 537825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setOperationAction(ISD::CONCAT_VECTORS, (MVT::SimpleValueType)VT, Expand); 5385ff839fbabe8b1d26cf4db5c541eb5d7942c25d6Evan Cheng } 539d2cde68855125b6815b1575f29cd96927614b0cdEvan Cheng 540d2cde68855125b6815b1575f29cd96927614b0cdEvan Cheng // Most targets ignore the @llvm.prefetch intrinsic. 541825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setOperationAction(ISD::PREFETCH, MVT::Other, Expand); 542bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 543bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // ConstantFP nodes default to expand. Targets can either change this to 544eb2f969a4ddfb0bc8fdcb5bce3b52e53abff321dEvan Cheng // Legal, in which case all fp constants are legal, or use isFPImmLegal() 545e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman // to optimize expansions for certain constants. 546e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::ConstantFP, MVT::f16, Expand); 547825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setOperationAction(ISD::ConstantFP, MVT::f32, Expand); 548825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setOperationAction(ISD::ConstantFP, MVT::f64, Expand); 549825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setOperationAction(ISD::ConstantFP, MVT::f80, Expand); 550310968cbbb564c4141d4bd418a746e8103560222Chris Lattner 5510bb41608e94adfe9884bc188457c4f6ae47ea43cDale Johannesen // These library functions default to expand. 552e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FLOG , MVT::f16, Expand); 553e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FLOG2, MVT::f16, Expand); 554e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FLOG10, MVT::f16, Expand); 555e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FEXP , MVT::f16, Expand); 556e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FEXP2, MVT::f16, Expand); 557e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FFLOOR, MVT::f16, Expand); 558e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FNEARBYINT, MVT::f16, Expand); 559e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FCEIL, MVT::f16, Expand); 560e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FRINT, MVT::f16, Expand); 561e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FTRUNC, MVT::f16, Expand); 5624a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FLOG , MVT::f32, Expand); 5634a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FLOG2, MVT::f32, Expand); 5644a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FLOG10, MVT::f32, Expand); 5654a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FEXP , MVT::f32, Expand); 5664a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FEXP2, MVT::f32, Expand); 5674a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FFLOOR, MVT::f32, Expand); 5684a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FNEARBYINT, MVT::f32, Expand); 5694a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FCEIL, MVT::f32, Expand); 5704a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FRINT, MVT::f32, Expand); 5714a4fdf3476473021f62d5b02e8ee8802f5b25e5aOwen Anderson setOperationAction(ISD::FTRUNC, MVT::f32, Expand); 572e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FLOG , MVT::f64, Expand); 573e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FLOG2, MVT::f64, Expand); 574e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FLOG10, MVT::f64, Expand); 575e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FEXP , MVT::f64, Expand); 576e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FEXP2, MVT::f64, Expand); 577e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FFLOOR, MVT::f64, Expand); 578e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FNEARBYINT, MVT::f64, Expand); 579e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FCEIL, MVT::f64, Expand); 580e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FRINT, MVT::f64, Expand); 581e3376ecd504300ae529c902135f51baffbdc2824Dan Gohman setOperationAction(ISD::FTRUNC, MVT::f64, Expand); 5820bb41608e94adfe9884bc188457c4f6ae47ea43cDale Johannesen 58341bab0beac2600701af99f63e23a6b65f71468acChris Lattner // Default ISD::TRAP to expand (which turns it into abort). 584825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson setOperationAction(ISD::TRAP, MVT::Other, Expand); 585bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 586a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson IsLittleEndian = TD->isLittleEndian(); 58795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson PointerTy = MVT::getIntegerVT(8*TD->getPointerSize()); 588825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson memset(RegClassForVT, 0,MVT::LAST_VALUETYPE*sizeof(TargetRegisterClass*)); 589718cb665ca6ce2bc4d8e8479f46a45db91b49f86Owen Anderson memset(TargetDAGCombineArray, 0, array_lengthof(TargetDAGCombineArray)); 590a03a5dc7ce876dac4b3b91bae14216de4233bacdEvan Cheng maxStoresPerMemset = maxStoresPerMemcpy = maxStoresPerMemmove = 8; 5910521928ae7cc492f3f45ef0e0cedc349102489c5Evan Cheng maxStoresPerMemsetOptSize = maxStoresPerMemcpyOptSize 5920521928ae7cc492f3f45ef0e0cedc349102489c5Evan Cheng = maxStoresPerMemmoveOptSize = 4; 5936ebf7bc7405ee79d27d50b70f0c1a474cbea820dEvan Cheng benefitFromCodePlacementOpt = false; 594d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov UseUnderscoreSetJmp = false; 595d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov UseUnderscoreLongJmp = false; 5966618039f9f1f2e41fe2742d83007c68bdebc3656Chris Lattner SelectIsExpensive = false; 597405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman IntDivIsCheap = false; 598405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman Pow2DivIsCheap = false; 599de189be53f5831737f38e720f10dbcdcce6876c6Chris Lattner JumpIsExpensive = false; 600aaf723dd2bccc052d2dd28e3cc4db76f2a3e2fb0Benjamin Kramer predictableSelectIsExpensive = false; 601ee4a76563a84839453588104e94d4891fc44d625Chris Lattner StackPointerRegisterToSaveRestore = 0; 6029bb3c93af271449dcbfce9f7fb7442dd11d93813Jim Laskey ExceptionPointerRegister = 0; 6039bb3c93af271449dcbfce9f7fb7442dd11d93813Jim Laskey ExceptionSelectorRegister = 0; 60403228089d5235f8c90477f88809139464e9c6ea5Duncan Sands BooleanContents = UndefinedBooleanContent; 60528b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands BooleanVectorContents = UndefinedBooleanContent; 6068c2d270ae8b460912633883f24346c0763373a56Dan Gohman SchedPreferenceInfo = Sched::ILP; 6077acf5f39fea463df5ad196affbef0176f3b25e0fChris Lattner JumpBufSize = 0; 6080c9e0ff24900aa2bcae9518f8b1bdc3fd41dc2edDuraid Madina JumpBufAlignment = 0; 609fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman MinFunctionAlignment = 0; 610fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman PrefFunctionAlignment = 0; 611fb8075d03f5c87bd57dcc9c5f2304f6b13c55aadEvan Cheng PrefLoopAlignment = 0; 612cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola MinStackArgumentAlignment = 1; 6139a526495e0c06c4014d7500788cad1929fd244d3Jim Grosbach ShouldFoldAtomicFences = false; 61426689ac37ebec3b358588089415509285e558de9Eli Friedman InsertFencesForAtomic = false; 615769951f6cc6323821ce1e9f46a37817a541c884fEvan Cheng SupportJumpTables = true; 61656966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng 61756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng InitLibcallNames(LibcallRoutineNames); 618d385fd62cb43435b3ad70d789198d34bf148e579Evan Cheng InitCmpLibcallCCs(CmpLibcallCCs); 61972977a45a8ad9d9524c9b49399e89fb9a3a676edAnton Korobeynikov InitLibcallCallingConvs(LibcallCallingConvs); 620310968cbbb564c4141d4bd418a746e8103560222Chris Lattner} 621310968cbbb564c4141d4bd418a746e8103560222Chris Lattner 622f0144127b98425d214e59e4a1a4b342b78e3642bChris LattnerTargetLowering::~TargetLowering() { 623f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner delete &TLOF; 624f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner} 625cba82f9339566cef76ecb062980e40913e6ccc23Chris Lattner 62695771afbfd604ad003fa3723cac66c9370fed55dOwen AndersonMVT TargetLowering::getShiftAmountTy(EVT LHSTy) const { 62795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson return MVT::getIntegerVT(8*TD->getPointerSize()); 62895771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson} 62995771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson 630f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang/// canOpTrap - Returns true if the operation can trap for the value type. 631f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang/// VT must be a legal type. 632f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wangbool TargetLowering::canOpTrap(unsigned Op, EVT VT) const { 633f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang assert(isTypeLegal(VT)); 634f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang switch (Op) { 635f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang default: 636f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang return false; 637f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang case ISD::FDIV: 638f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang case ISD::FREM: 639f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang case ISD::SDIV: 640f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang case ISD::UDIV: 641f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang case ISD::SREM: 642f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang case ISD::UREM: 643f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang return true; 644f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang } 645f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang} 646f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang 647f7ea6c3ee89e605c8d0bb7cdb0ade79706c750e8Mon P Wang 64823b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Andersonstatic unsigned getVectorTypeBreakdownMVT(MVT VT, MVT &IntermediateVT, 649598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner unsigned &NumIntermediates, 650598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner EVT &RegisterVT, 651598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner TargetLowering *TLI) { 65223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson // Figure out the right, legal destination reg to copy into. 65323b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson unsigned NumElts = VT.getVectorNumElements(); 65423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson MVT EltTy = VT.getVectorElementType(); 655bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 65623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson unsigned NumVectorRegs = 1; 657bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 658bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // FIXME: We don't support non-power-of-2-sized vectors for now. Ideally we 65923b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson // could break down into LHS/RHS like LegalizeDAG does. 66023b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson if (!isPowerOf2_32(NumElts)) { 66123b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson NumVectorRegs = NumElts; 66223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson NumElts = 1; 66323b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson } 664bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 66523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson // Divide the input until we get to a supported size. This will always 66623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson // end with a scalar if the target doesn't support vectors. 66723b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson while (NumElts > 1 && !TLI->isTypeLegal(MVT::getVectorVT(EltTy, NumElts))) { 66823b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson NumElts >>= 1; 66923b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson NumVectorRegs <<= 1; 67023b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson } 67123b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson 67223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson NumIntermediates = NumVectorRegs; 673bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 67423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson MVT NewVT = MVT::getVectorVT(EltTy, NumElts); 67523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson if (!TLI->isTypeLegal(NewVT)) 67623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson NewVT = EltTy; 67723b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson IntermediateVT = NewVT; 67823b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson 6790c3e67860af417febb1fa9e870ece912a16085acNadav Rotem unsigned NewVTSize = NewVT.getSizeInBits(); 6800c3e67860af417febb1fa9e870ece912a16085acNadav Rotem 6810c3e67860af417febb1fa9e870ece912a16085acNadav Rotem // Convert sizes such as i33 to i64. 6820c3e67860af417febb1fa9e870ece912a16085acNadav Rotem if (!isPowerOf2_32(NewVTSize)) 6830c3e67860af417febb1fa9e870ece912a16085acNadav Rotem NewVTSize = NextPowerOf2(NewVTSize); 6840c3e67860af417febb1fa9e870ece912a16085acNadav Rotem 68523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT DestVT = TLI->getRegisterType(NewVT); 68623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson RegisterVT = DestVT; 68732b4b5aea6dc38ac5aaff56fc717aebf188e39c9Chris Lattner if (EVT(DestVT).bitsLT(NewVT)) // Value is expanded, e.g. i64 -> i16. 6880c3e67860af417febb1fa9e870ece912a16085acNadav Rotem return NumVectorRegs*(NewVTSize/DestVT.getSizeInBits()); 689bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 69032b4b5aea6dc38ac5aaff56fc717aebf188e39c9Chris Lattner // Otherwise, promotion or legal types use the same number of registers as 69132b4b5aea6dc38ac5aaff56fc717aebf188e39c9Chris Lattner // the vector decimated to the appropriate level. 69232b4b5aea6dc38ac5aaff56fc717aebf188e39c9Chris Lattner return NumVectorRegs; 69323b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson} 69423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson 69546dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng/// isLegalRC - Return true if the value types that can be represented by the 69646dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng/// specified register class are all legal. 69746dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Chengbool TargetLowering::isLegalRC(const TargetRegisterClass *RC) const { 69846dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 69946dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng I != E; ++I) { 70046dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng if (isTypeLegal(*I)) 70146dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng return true; 70246dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng } 70346dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng return false; 70446dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng} 70546dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng 70646dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng/// findRepresentativeClass - Return the largest legal super-reg register class 7074f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng/// of the register class for the specified type and its associated "cost". 7084f6b4674be5473319ac5e70c76fd5cb964da2128Evan Chengstd::pair<const TargetRegisterClass*, uint8_t> 7094f6b4674be5473319ac5e70c76fd5cb964da2128Evan ChengTargetLowering::findRepresentativeClass(EVT VT) const { 710e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen const TargetRegisterInfo *TRI = getTargetMachine().getRegisterInfo(); 7114f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng const TargetRegisterClass *RC = RegClassForVT[VT.getSimpleVT().SimpleTy]; 7124f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng if (!RC) 7134f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng return std::make_pair(RC, 0); 714e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen 715e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen // Compute the set of all super-register classes. 716e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen BitVector SuperRegRC(TRI->getNumRegClasses()); 7177fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen for (SuperRegClassIterator RCI(RC, TRI); RCI.isValid(); ++RCI) 718e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen SuperRegRC.setBitsInMask(RCI.getMask()); 719e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen 7207fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen // Find the first legal register class with the largest spill size. 7217fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen const TargetRegisterClass *BestRC = RC; 722e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen for (int i = SuperRegRC.find_first(); i >= 0; i = SuperRegRC.find_next(i)) { 723e3ee49fb2728dcb9702b5be0c3c80f472ffccefcJakob Stoklund Olesen const TargetRegisterClass *SuperRC = TRI->getRegClass(i); 7247fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen // We want the largest possible spill size. 7257fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen if (SuperRC->getSize() <= BestRC->getSize()) 7267fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen continue; 7277fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen if (!isLegalRC(SuperRC)) 7287fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen continue; 7297fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen BestRC = SuperRC; 73046dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng } 7317fc4d9cbc54c2e5393440a40b566c1f0527d8037Jakob Stoklund Olesen return std::make_pair(BestRC, 1); 73246dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng} 73346dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng 734310968cbbb564c4141d4bd418a746e8103560222Chris Lattner/// computeRegisterProperties - Once all of the register classes are added, 735310968cbbb564c4141d4bd418a746e8103560222Chris Lattner/// this allows us to compute derived properties we expose. 736310968cbbb564c4141d4bd418a746e8103560222Chris Lattnervoid TargetLowering::computeRegisterProperties() { 737825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert(MVT::LAST_VALUETYPE <= MVT::MAX_ALLOWED_VALUETYPE && 738bb97d81cc873e2c0914f2ece43832723cc936d24Chris Lattner "Too many value types for ValueTypeActions to hold!"); 739bb97d81cc873e2c0914f2ece43832723cc936d24Chris Lattner 740b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Everything defaults to needing one register. 741825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson for (unsigned i = 0; i != MVT::LAST_VALUETYPE; ++i) { 742b9f10196961ebe5b5573a5705048a5a8a6b56bb3Dan Gohman NumRegistersForVT[i] = 1; 743825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson RegisterTypeForVT[i] = TransformToType[i] = (MVT::SimpleValueType)i; 744b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } 745b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // ...except isVoid, which doesn't need any registers. 746825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson NumRegistersForVT[MVT::isVoid] = 0; 747f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 748310968cbbb564c4141d4bd418a746e8103560222Chris Lattner // Find the largest integer register class. 749825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson unsigned LargestIntReg = MVT::LAST_INTEGER_VALUETYPE; 750310968cbbb564c4141d4bd418a746e8103560222Chris Lattner for (; RegClassForVT[LargestIntReg] == 0; --LargestIntReg) 751825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert(LargestIntReg != MVT::i1 && "No integer registers defined!"); 752310968cbbb564c4141d4bd418a746e8103560222Chris Lattner 753310968cbbb564c4141d4bd418a746e8103560222Chris Lattner // Every integer value type larger than this largest register takes twice as 754310968cbbb564c4141d4bd418a746e8103560222Chris Lattner // many registers to represent as the previous ValueType. 75583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands for (unsigned ExpandedReg = LargestIntReg + 1; ; ++ExpandedReg) { 7568a55ce4a392f07ac1f3c183100ac591b7ad7c693Dan Gohman EVT ExpandedVT = (MVT::SimpleValueType)ExpandedReg; 7578a55ce4a392f07ac1f3c183100ac591b7ad7c693Dan Gohman if (!ExpandedVT.isInteger()) 75883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands break; 759b9f10196961ebe5b5573a5705048a5a8a6b56bb3Dan Gohman NumRegistersForVT[ExpandedReg] = 2*NumRegistersForVT[ExpandedReg-1]; 760825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson RegisterTypeForVT[ExpandedReg] = (MVT::SimpleValueType)LargestIntReg; 761825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson TransformToType[ExpandedReg] = (MVT::SimpleValueType)(ExpandedReg - 1); 762b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(ExpandedVT, TypeExpandInteger); 763b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } 764310968cbbb564c4141d4bd418a746e8103560222Chris Lattner 765b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Inspect all of the ValueType's smaller than the largest integer 766b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // register to see which ones need promotion. 76783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned LegalIntReg = LargestIntReg; 76883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands for (unsigned IntReg = LargestIntReg - 1; 769825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson IntReg >= (unsigned)MVT::i1; --IntReg) { 770825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson EVT IVT = (MVT::SimpleValueType)IntReg; 77183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (isTypeLegal(IVT)) { 772b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman LegalIntReg = IntReg; 773b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } else { 77483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands RegisterTypeForVT[IntReg] = TransformToType[IntReg] = 77559324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky (const MVT::SimpleValueType)LegalIntReg; 776b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(IVT, TypePromoteInteger); 777b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } 778b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } 779f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 780161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen // ppcf128 type is really two f64's. 781825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (!isTypeLegal(MVT::ppcf128)) { 782825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson NumRegistersForVT[MVT::ppcf128] = 2*NumRegistersForVT[MVT::f64]; 783825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson RegisterTypeForVT[MVT::ppcf128] = MVT::f64; 784825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson TransformToType[MVT::ppcf128] = MVT::f64; 785b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(MVT::ppcf128, TypeExpandFloat); 786bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 787161e897b0fb35d156b2fe720fadabd975b0d6723Dale Johannesen 788b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Decide how to handle f64. If the target does not have native f64 support, 789b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // expand it to i64 and we will be generating soft float library calls. 790825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (!isTypeLegal(MVT::f64)) { 791825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson NumRegistersForVT[MVT::f64] = NumRegistersForVT[MVT::i64]; 792825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson RegisterTypeForVT[MVT::f64] = RegisterTypeForVT[MVT::i64]; 793825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson TransformToType[MVT::f64] = MVT::i64; 794b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(MVT::f64, TypeSoftenFloat); 7951a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng } 796b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 797b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Decide how to handle f32. If the target does not have native support for 798b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // f32, promote it to f64 if it is legal. Otherwise, expand it to i32. 799825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (!isTypeLegal(MVT::f32)) { 800825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (isTypeLegal(MVT::f64)) { 801825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson NumRegistersForVT[MVT::f32] = NumRegistersForVT[MVT::f64]; 802825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson RegisterTypeForVT[MVT::f32] = RegisterTypeForVT[MVT::f64]; 803825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson TransformToType[MVT::f32] = MVT::f64; 804b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(MVT::f32, TypePromoteInteger); 805b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } else { 806825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson NumRegistersForVT[MVT::f32] = NumRegistersForVT[MVT::i32]; 807825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson RegisterTypeForVT[MVT::f32] = RegisterTypeForVT[MVT::i32]; 808825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson TransformToType[MVT::f32] = MVT::i32; 809b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(MVT::f32, TypeSoftenFloat); 810b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } 8111a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng } 812bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 813b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Loop over all of the vector value types to see which need transformations. 814825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson for (unsigned i = MVT::FIRST_VECTOR_VALUETYPE; 815825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson i <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++i) { 81623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson MVT VT = (MVT::SimpleValueType)i; 817598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner if (isTypeLegal(VT)) continue; 818bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 819e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner // Determine if there is a legal wider type. If so, we should promote to 820e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner // that wider vector type. 821e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner EVT EltVT = VT.getVectorElementType(); 822e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner unsigned NElts = VT.getVectorNumElements(); 823e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner if (NElts != 1) { 824e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner bool IsLegalWiderType = false; 825f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem // First try to promote the elements of integer vectors. If no legal 826f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem // promotion was found, fallback to the widen-vector method. 827e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner for (unsigned nVT = i+1; nVT <= MVT::LAST_VECTOR_VALUETYPE; ++nVT) { 828e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner EVT SVT = (MVT::SimpleValueType)nVT; 829f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem // Promote vectors of integers to vectors with the same number 830f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem // of elements, with a wider element type. 831f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem if (SVT.getVectorElementType().getSizeInBits() > EltVT.getSizeInBits() 832f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem && SVT.getVectorNumElements() == NElts && 833f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem isTypeLegal(SVT) && SVT.getScalarType().isInteger()) { 834f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem TransformToType[i] = SVT; 835f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem RegisterTypeForVT[i] = SVT; 836f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem NumRegistersForVT[i] = 1; 837f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem ValueTypeActions.setTypeAction(VT, TypePromoteInteger); 838f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem IsLegalWiderType = true; 839f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem break; 840b6fbec3a546fd04bb2e79040db2436b0bd629162Nadav Rotem } 841f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem } 842f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem 843f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem if (IsLegalWiderType) continue; 844b6fbec3a546fd04bb2e79040db2436b0bd629162Nadav Rotem 845f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem // Try to widen the vector. 846f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem for (unsigned nVT = i+1; nVT <= MVT::LAST_VECTOR_VALUETYPE; ++nVT) { 847f1c025d1d106905df3d38d2482fde68c8f81b107Nadav Rotem EVT SVT = (MVT::SimpleValueType)nVT; 848e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner if (SVT.getVectorElementType() == EltVT && 849bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SVT.getVectorNumElements() > NElts && 850e93d99cf0742eebab859022e4cfdcf03cb9d5dfaDale Johannesen isTypeLegal(SVT)) { 851e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner TransformToType[i] = SVT; 852e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner RegisterTypeForVT[i] = SVT; 853e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner NumRegistersForVT[i] = 1; 854b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(VT, TypeWidenVector); 855e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner IsLegalWiderType = true; 856e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner break; 857e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner } 858e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner } 859e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner if (IsLegalWiderType) continue; 860e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner } 861bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 862598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner MVT IntermediateVT; 863598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner EVT RegisterVT; 864598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner unsigned NumIntermediates; 865598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner NumRegistersForVT[i] = 866598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner getVectorTypeBreakdownMVT(VT, IntermediateVT, NumIntermediates, 867598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner RegisterVT, this); 868598751ed2544291ba623e013b4e0b61bf56ca9c4Chris Lattner RegisterTypeForVT[i] = RegisterVT; 869bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 870e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner EVT NVT = VT.getPow2VectorType(); 871e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner if (NVT == VT) { 872e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner // Type is already a power of 2. The default action is to split. 873e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner TransformToType[i] = MVT::Other; 874b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem unsigned NumElts = VT.getVectorNumElements(); 875b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(VT, 876b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem NumElts > 1 ? TypeSplitVector : TypeScalarizeVector); 877e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner } else { 878e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner TransformToType[i] = NVT; 879b6aacae9413adde66d9686cd9e561eb836b3ee34Nadav Rotem ValueTypeActions.setTypeAction(VT, TypeWidenVector); 8807f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 8813a59358499f527ad9a8d1d4ed7d80b6bf0f1c12dChris Lattner } 88246dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng 88346dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng // Determine the 'representative' register class for each value type. 88446dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng // An representative register class is the largest (meaning one which is 88546dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng // not a sub-register class / subreg register class) legal register class for 88646dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng // a group of value types. For example, on i386, i8, i16, and i32 88746dcb57e18884099ca6ad2aebb81fd7e1513c1f6Evan Cheng // representative would be GR32; while on x86_64 it's GR64. 888d70f57b254114841892425a40944268d38ae0bcdEvan Cheng for (unsigned i = 0; i != MVT::LAST_VALUETYPE; ++i) { 8894f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng const TargetRegisterClass* RRC; 8904f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng uint8_t Cost; 8914f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng tie(RRC, Cost) = findRepresentativeClass((MVT::SimpleValueType)i); 8924f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng RepRegClassForVT[i] = RRC; 8934f6b4674be5473319ac5e70c76fd5cb964da2128Evan Cheng RepRegClassCostForVT[i] = Cost; 894d70f57b254114841892425a40944268d38ae0bcdEvan Cheng } 895bb97d81cc873e2c0914f2ece43832723cc936d24Chris Lattner} 896cba82f9339566cef76ecb062980e40913e6ccc23Chris Lattner 8977226158d7e3986e55b58214a749aa4eabb3fb6d5Evan Chengconst char *TargetLowering::getTargetNodeName(unsigned Opcode) const { 8987226158d7e3986e55b58214a749aa4eabb3fb6d5Evan Cheng return NULL; 8997226158d7e3986e55b58214a749aa4eabb3fb6d5Evan Cheng} 9003a03ebb37747c2b3fd9b4f8b44f1124f53727894Evan Cheng 90128b77e968d2b01fc9da724762bd8ddcd80650e32Duncan SandsEVT TargetLowering::getSetCCResultType(EVT VT) const { 90228b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands assert(!VT.isVector() && "No default SetCC type for vectors!"); 9031d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson return PointerTy.SimpleTy; 9045b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel} 9055b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel 9068f17a36d3107bdc4ffed53ce782c1724ef6460e7Sanjiv GuptaMVT::SimpleValueType TargetLowering::getCmpLibcallReturnType() const { 9078f17a36d3107bdc4ffed53ce782c1724ef6460e7Sanjiv Gupta return MVT::i32; // return the default value 9088f17a36d3107bdc4ffed53ce782c1724ef6460e7Sanjiv Gupta} 9098f17a36d3107bdc4ffed53ce782c1724ef6460e7Sanjiv Gupta 9107f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman/// getVectorTypeBreakdown - Vector types are broken down into some number of 911825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson/// legal first class types. For example, MVT::v8f32 maps to 2 MVT::v4f32 912825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson/// with Altivec or SSE1, or 8 promoted MVT::f64 values with the X86 FP stack. 913825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson/// Similarly, MVT::v2i64 turns into 4 MVT::i32 values with both PPC and X86. 914dc879296090a738c66968f5eec77db65d7e03623Chris Lattner/// 9157f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman/// This method returns the number of registers needed, and the VT for each 916b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// register. It also returns the VT and quantity of the intermediate values 917b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// before they are promoted/expanded. 918dc879296090a738c66968f5eec77db65d7e03623Chris Lattner/// 91923b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Andersonunsigned TargetLowering::getVectorTypeBreakdown(LLVMContext &Context, EVT VT, 920e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT &IntermediateVT, 921b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman unsigned &NumIntermediates, 92223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT &RegisterVT) const { 92383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NumElts = VT.getVectorNumElements(); 924bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 925e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner // If there is a wider vector type with the same element type as this one, 926db3461662e7945e04fe42e0d606581bba73c29dcNadav Rotem // or a promoted vector type that has the same number of elements which 927db3461662e7945e04fe42e0d606581bba73c29dcNadav Rotem // are wider, then we should convert to that legal vector type. 928db3461662e7945e04fe42e0d606581bba73c29dcNadav Rotem // This handles things like <2 x float> -> <4 x float> and 929db3461662e7945e04fe42e0d606581bba73c29dcNadav Rotem // <4 x i1> -> <4 x i32>. 930db3461662e7945e04fe42e0d606581bba73c29dcNadav Rotem LegalizeTypeAction TA = getTypeAction(Context, VT); 931db3461662e7945e04fe42e0d606581bba73c29dcNadav Rotem if (NumElts != 1 && (TA == TypeWidenVector || TA == TypePromoteInteger)) { 932e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner RegisterVT = getTypeToTransformTo(Context, VT); 933e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner if (isTypeLegal(RegisterVT)) { 934e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner IntermediateVT = RegisterVT; 935e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner NumIntermediates = 1; 936e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner return 1; 937e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner } 938e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner } 939bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 940e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner // Figure out the right, legal destination reg to copy into. 941e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT EltTy = VT.getVectorElementType(); 942bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 943dc879296090a738c66968f5eec77db65d7e03623Chris Lattner unsigned NumVectorRegs = 1; 944bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 945bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // FIXME: We don't support non-power-of-2-sized vectors for now. Ideally we 946d73ab8884f5c95d2704be3c00af4cc3dba963da6Nate Begeman // could break down into LHS/RHS like LegalizeDAG does. 947d73ab8884f5c95d2704be3c00af4cc3dba963da6Nate Begeman if (!isPowerOf2_32(NumElts)) { 948d73ab8884f5c95d2704be3c00af4cc3dba963da6Nate Begeman NumVectorRegs = NumElts; 949d73ab8884f5c95d2704be3c00af4cc3dba963da6Nate Begeman NumElts = 1; 950d73ab8884f5c95d2704be3c00af4cc3dba963da6Nate Begeman } 951bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 952dc879296090a738c66968f5eec77db65d7e03623Chris Lattner // Divide the input until we get to a supported size. This will always 953dc879296090a738c66968f5eec77db65d7e03623Chris Lattner // end with a scalar if the target doesn't support vectors. 95423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson while (NumElts > 1 && !isTypeLegal( 95523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT::getVectorVT(Context, EltTy, NumElts))) { 956dc879296090a738c66968f5eec77db65d7e03623Chris Lattner NumElts >>= 1; 957dc879296090a738c66968f5eec77db65d7e03623Chris Lattner NumVectorRegs <<= 1; 958dc879296090a738c66968f5eec77db65d7e03623Chris Lattner } 959b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 960b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman NumIntermediates = NumVectorRegs; 961bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 96223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NewVT = EVT::getVectorVT(Context, EltTy, NumElts); 9637f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (!isTypeLegal(NewVT)) 9647f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman NewVT = EltTy; 965b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman IntermediateVT = NewVT; 966dc879296090a738c66968f5eec77db65d7e03623Chris Lattner 96723b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT DestVT = getRegisterType(Context, NewVT); 968b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman RegisterVT = DestVT; 9690c3e67860af417febb1fa9e870ece912a16085acNadav Rotem unsigned NewVTSize = NewVT.getSizeInBits(); 9700c3e67860af417febb1fa9e870ece912a16085acNadav Rotem 9710c3e67860af417febb1fa9e870ece912a16085acNadav Rotem // Convert sizes such as i33 to i64. 9720c3e67860af417febb1fa9e870ece912a16085acNadav Rotem if (!isPowerOf2_32(NewVTSize)) 9730c3e67860af417febb1fa9e870ece912a16085acNadav Rotem NewVTSize = NextPowerOf2(NewVTSize); 9740c3e67860af417febb1fa9e870ece912a16085acNadav Rotem 975e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner if (DestVT.bitsLT(NewVT)) // Value is expanded, e.g. i64 -> i16. 9760c3e67860af417febb1fa9e870ece912a16085acNadav Rotem return NumVectorRegs*(NewVTSize/DestVT.getSizeInBits()); 977bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 978e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner // Otherwise, promotion or legal types use the same number of registers as 979e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner // the vector decimated to the appropriate level. 980e6f7c267df11a44679c35dec79787fbc276839fbChris Lattner return NumVectorRegs; 981dc879296090a738c66968f5eec77db65d7e03623Chris Lattner} 982dc879296090a738c66968f5eec77db65d7e03623Chris Lattner 983bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck/// Get the EVTs and ArgFlags collections that represent the legalized return 98484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// type of the given function. This does not require a DAG or a return value, 98584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// and is suitable for use before any DAGs for the function are constructed. 98684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// TODO: Move this out of TargetLowering.cpp. 987db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnervoid llvm::GetReturnInfo(Type* ReturnType, Attributes attr, 98884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman SmallVectorImpl<ISD::OutputArg> &Outs, 9892db0e9ebb600a2e6b8f651f66a1ef50e0d3c3c6bEli Friedman const TargetLowering &TLI) { 99084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman SmallVector<EVT, 4> ValueVTs; 99184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ComputeValueVTs(TLI, ReturnType, ValueVTs); 99284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman unsigned NumValues = ValueVTs.size(); 99384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (NumValues == 0) return; 99484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 99584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman for (unsigned j = 0, f = NumValues; j != f; ++j) { 99684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman EVT VT = ValueVTs[j]; 99784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ISD::NodeType ExtendKind = ISD::ANY_EXTEND; 99884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 99984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (attr & Attribute::SExt) 100084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ExtendKind = ISD::SIGN_EXTEND; 100184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman else if (attr & Attribute::ZExt) 100284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ExtendKind = ISD::ZERO_EXTEND; 100384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 100484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // FIXME: C calling convention requires the return type to be promoted to 100584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // at least 32-bit. But this is not necessary for non-C calling 100684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // conventions. The frontend should mark functions whose return values 100784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // require promoting with signext or zeroext attributes. 100884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger()) { 100984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman EVT MinVT = TLI.getRegisterType(ReturnType->getContext(), MVT::i32); 101084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (VT.bitsLT(MinVT)) 101184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman VT = MinVT; 101284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 101384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 101484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman unsigned NumParts = TLI.getNumRegisters(ReturnType->getContext(), VT); 101584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman EVT PartVT = TLI.getRegisterType(ReturnType->getContext(), VT); 101684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 101784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // 'inreg' on function refers to return value 101884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy(); 101984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (attr & Attribute::InReg) 102084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Flags.setInReg(); 102184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 102284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Propagate extension type if any 102384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (attr & Attribute::SExt) 102484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Flags.setSExt(); 102584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman else if (attr & Attribute::ZExt) 102684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Flags.setZExt(); 102784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 102884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman for (unsigned i = 0; i < NumParts; ++i) { 102984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Outs.push_back(ISD::OutputArg(Flags, PartVT, /*isFixed=*/true)); 103084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 103184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 103284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 103384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 10343ae054385cfe9f2fcef2d77f26839615b1d3e48bEvan Cheng/// getByValTypeAlignment - Return the desired alignment for ByVal aggregate 103528d08fdb9f6572cafd5aae95c7caffa3cd136d8eDale Johannesen/// function arguments in the caller parameter area. This is the actual 103628d08fdb9f6572cafd5aae95c7caffa3cd136d8eDale Johannesen/// alignment, not its logarithm. 1037db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerunsigned TargetLowering::getByValTypeAlignment(Type *Ty) const { 103828d08fdb9f6572cafd5aae95c7caffa3cd136d8eDale Johannesen return TD->getCallFrameTypeAlignment(Ty); 10393ae054385cfe9f2fcef2d77f26839615b1d3e48bEvan Cheng} 10403ae054385cfe9f2fcef2d77f26839615b1d3e48bEvan Cheng 1041071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner/// getJumpTableEncoding - Return the entry encoding for a jump table in the 1042071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner/// current function. The returned value is a member of the 1043071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner/// MachineJumpTableInfo::JTEntryKind enum. 1044071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattnerunsigned TargetLowering::getJumpTableEncoding() const { 1045071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // In non-pic modes, just use the address of a block. 1046071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (getTargetMachine().getRelocationModel() != Reloc::PIC_) 1047071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return MachineJumpTableInfo::EK_BlockAddress; 1048bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1049071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // In PIC mode, if the target supports a GPRel32 directive, use it. 1050071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (getTargetMachine().getMCAsmInfo()->getGPRel32Directive() != 0) 1051071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return MachineJumpTableInfo::EK_GPRel32BlockAddress; 1052bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1053071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // Otherwise, use a label difference. 1054071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return MachineJumpTableInfo::EK_LabelDifference32; 1055071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner} 1056071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 1057475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue TargetLowering::getPICJumpTableRelocBase(SDValue Table, 1058475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SelectionDAG &DAG) const { 1059f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // If our PIC model is GP relative, use the global offset table as the base. 1060787c3fd385834db61bd955dcc40fb02b77c183a9Akira Hatanaka unsigned JTEncoding = getJumpTableEncoding(); 1061787c3fd385834db61bd955dcc40fb02b77c183a9Akira Hatanaka 1062787c3fd385834db61bd955dcc40fb02b77c183a9Akira Hatanaka if ((JTEncoding == MachineJumpTableInfo::EK_GPRel64BlockAddress) || 1063787c3fd385834db61bd955dcc40fb02b77c183a9Akira Hatanaka (JTEncoding == MachineJumpTableInfo::EK_GPRel32BlockAddress)) 1064b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen return DAG.getGLOBAL_OFFSET_TABLE(getPointerTy()); 1065787c3fd385834db61bd955dcc40fb02b77c183a9Akira Hatanaka 1066cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng return Table; 1067cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng} 1068cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng 106913e97a29d9dfa5602f93a8c546f112c5d029e8f7Chris Lattner/// getPICJumpTableRelocBaseExpr - This returns the relocation base for the 107013e97a29d9dfa5602f93a8c546f112c5d029e8f7Chris Lattner/// given PIC jumptable, the same as getPICJumpTableRelocBase, but as an 107113e97a29d9dfa5602f93a8c546f112c5d029e8f7Chris Lattner/// MCExpr. 107213e97a29d9dfa5602f93a8c546f112c5d029e8f7Chris Lattnerconst MCExpr * 1073589c6f620e8dcf3d59af1ae0e15372c934647c82Chris LattnerTargetLowering::getPICJumpTableRelocBaseExpr(const MachineFunction *MF, 1074589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner unsigned JTI,MCContext &Ctx) const{ 1075beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner // The normal PIC reloc base is the label at the start of the jump table. 1076589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner return MCSymbolRefExpr::Create(MF->getJTISymbol(JTI, Ctx), Ctx); 107713e97a29d9dfa5602f93a8c546f112c5d029e8f7Chris Lattner} 107813e97a29d9dfa5602f93a8c546f112c5d029e8f7Chris Lattner 10796520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohmanbool 10806520e20e4fb31f2e65e25c38b372b19d33a83df4Dan GohmanTargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const { 10816520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman // Assume that everything is safe in static mode. 10826520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman if (getTargetMachine().getRelocationModel() == Reloc::Static) 10836520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman return true; 10846520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman 10856520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman // In dynamic-no-pic mode, assume that known defined values are safe. 10866520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman if (getTargetMachine().getRelocationModel() == Reloc::DynamicNoPIC && 10876520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman GA && 10886520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman !GA->getGlobal()->isDeclaration() && 1089667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands !GA->getGlobal()->isWeakForLinker()) 10906520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman return true; 10916520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman 10926520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman // Otherwise assume nothing is safe. 10936520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman return false; 10946520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman} 10956520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman 1096eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner//===----------------------------------------------------------------------===// 1097eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner// Optimization Methods 1098eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner//===----------------------------------------------------------------------===// 1099eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner 1100bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck/// ShrinkDemandedConstant - Check to see if the specified operand of the 1101368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// specified instruction is a constant integer. If so, check to see if there 1102368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// are any bits set in the constant that are not demanded. If so, shrink the 1103368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// constant and return true. 1104bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckbool TargetLowering::TargetLoweringOpt::ShrinkDemandedConstant(SDValue Op, 11057b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman const APInt &Demanded) { 1106de06470330260f5937e7ca558f5f5b3e171f2ee5Dale Johannesen DebugLoc dl = Op.getDebugLoc(); 110736ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling 1108ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // FIXME: ISD::SELECT, ISD::SELECT_CC 1109e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman switch (Op.getOpcode()) { 1110368e18d56a87308045d341e85584597bfe7426e9Nate Begeman default: break; 1111368e18d56a87308045d341e85584597bfe7426e9Nate Begeman case ISD::XOR: 111236ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling case ISD::AND: 111336ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling case ISD::OR: { 111436ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1)); 111536ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling if (!C) return false; 111636ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling 111736ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling if (Op.getOpcode() == ISD::XOR && 111836ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling (C->getAPIntValue() | (~Demanded)).isAllOnesValue()) 111936ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling return false; 112036ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling 112136ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling // if we can expand it to have all bits set, do it 112236ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling if (C->getAPIntValue().intersects(~Demanded)) { 1123e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 112436ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling SDValue New = DAG.getNode(Op.getOpcode(), dl, VT, Op.getOperand(0), 112536ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling DAG.getConstant(Demanded & 1126bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck C->getAPIntValue(), 112736ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling VT)); 112836ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling return CombineTo(Op, New); 112936ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling } 113036ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling 1131368e18d56a87308045d341e85584597bfe7426e9Nate Begeman break; 1132368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } 113336ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling } 113436ae6c182759871a4af71d9af85f970b29a669f1Bill Wendling 1135368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return false; 1136368e18d56a87308045d341e85584597bfe7426e9Nate Begeman} 1137368e18d56a87308045d341e85584597bfe7426e9Nate Begeman 113897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman/// ShrinkDemandedOp - Convert x+y to (VT)((SmallVT)x+(SmallVT)y) if the 113997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman/// casts are free. This uses isZExtFree and ZERO_EXTEND for the widening 114097121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman/// cast, but it could be generalized for targets with other types of 114197121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman/// implicit widening casts. 114297121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohmanbool 114397121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan GohmanTargetLowering::TargetLoweringOpt::ShrinkDemandedOp(SDValue Op, 114497121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman unsigned BitWidth, 114597121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman const APInt &Demanded, 114697121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman DebugLoc dl) { 114797121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman assert(Op.getNumOperands() == 2 && 114897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman "ShrinkDemandedOp only supports binary operators!"); 114997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman assert(Op.getNode()->getNumValues() == 1 && 115097121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman "ShrinkDemandedOp only supports nodes with one result!"); 115197121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman 115297121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // Don't do this if the node has another user, which may require the 115397121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // full value. 115497121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman if (!Op.getNode()->hasOneUse()) 115597121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return false; 115697121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman 115797121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // Search for the smallest integer type with free casts to and from 115897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // Op's type. For expedience, just check power-of-2 integer types. 115997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman const TargetLowering &TLI = DAG.getTargetLoweringInfo(); 116097121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman unsigned SmallVTBits = BitWidth - Demanded.countLeadingZeros(); 116197121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman if (!isPowerOf2_32(SmallVTBits)) 116297121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman SmallVTBits = NextPowerOf2(SmallVTBits); 116397121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman for (; SmallVTBits < BitWidth; SmallVTBits = NextPowerOf2(SmallVTBits)) { 116423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), SmallVTBits); 116597121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman if (TLI.isTruncateFree(Op.getValueType(), SmallVT) && 116697121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman TLI.isZExtFree(SmallVT, Op.getValueType())) { 116797121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // We found a type with free casts. 116897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman SDValue X = DAG.getNode(Op.getOpcode(), dl, SmallVT, 116997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman DAG.getNode(ISD::TRUNCATE, dl, SmallVT, 117097121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman Op.getNode()->getOperand(0)), 117197121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman DAG.getNode(ISD::TRUNCATE, dl, SmallVT, 117297121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman Op.getNode()->getOperand(1))); 117397121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman SDValue Z = DAG.getNode(ISD::ZERO_EXTEND, dl, Op.getValueType(), X); 117497121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return CombineTo(Op, Z); 117597121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman } 117697121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman } 117797121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return false; 117897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman} 117997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman 1180368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// SimplifyDemandedBits - Look at Op. At this point, we know that only the 11818c1ec5a0a21dcb3364aace8174f29f209ff3224eChad Rosier/// DemandedMask bits of the result of Op are ever used downstream. If we can 1182368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// use this information to simplify Op, create a new simplified DAG node and 1183368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// return true, returning the original and new nodes in Old and New. Otherwise, 1184368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// analyze the expression and return a mask of KnownOne and KnownZero bits for 1185368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// the expression (used to simplify the caller). The KnownZero/One bits may 1186368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// only be accurate for those bits in the DemandedMask. 1187475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanbool TargetLowering::SimplifyDemandedBits(SDValue Op, 11887b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman const APInt &DemandedMask, 11897b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt &KnownZero, 11907b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt &KnownOne, 1191368e18d56a87308045d341e85584597bfe7426e9Nate Begeman TargetLoweringOpt &TLO, 1192368e18d56a87308045d341e85584597bfe7426e9Nate Begeman unsigned Depth) const { 11937b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman unsigned BitWidth = DemandedMask.getBitWidth(); 119487862e77bbf90cf1b68c9eea1f3641ad81435e38Dan Gohman assert(Op.getValueType().getScalarType().getSizeInBits() == BitWidth && 11957b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman "Mask size mismatches value type size!"); 11967b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt NewMask = DemandedMask; 11976f38cb61a94b3abab70f0ee463bdcf55d86d334eDale Johannesen DebugLoc dl = Op.getDebugLoc(); 11987b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman 11997b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman // Don't know anything. 12007b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman KnownZero = KnownOne = APInt(BitWidth, 0); 12013fc5b01d38ddccbe53ff0b32cc0100351d698c66Chris Lattner 1202368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Other users may use these bits. 1203bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (!Op.getNode()->hasOneUse()) { 1204368e18d56a87308045d341e85584597bfe7426e9Nate Begeman if (Depth != 0) { 1205bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // If not at the root, Just compute the KnownZero/KnownOne bits to 1206368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // simplify things downstream. 120726c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola TLO.DAG.ComputeMaskedBits(Op, KnownZero, KnownOne, Depth); 1208368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return false; 1209368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } 1210368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If this is the root being simplified, allow it to have multiple uses, 12117b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman // just set the NewMask to all bits. 12127b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman NewMask = APInt::getAllOnesValue(BitWidth); 1213bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } else if (DemandedMask == 0) { 1214368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Not demanding any bits from Op. 1215368e18d56a87308045d341e85584597bfe7426e9Nate Begeman if (Op.getOpcode() != ISD::UNDEF) 1216e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen return TLO.CombineTo(Op, TLO.DAG.getUNDEF(Op.getValueType())); 1217de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman return false; 1218368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } else if (Depth == 6) { // Limit search depth. 1219368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return false; 1220368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } 1221368e18d56a87308045d341e85584597bfe7426e9Nate Begeman 12227b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt KnownZero2, KnownOne2, KnownZeroOut, KnownOneOut; 1223de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman switch (Op.getOpcode()) { 1224368e18d56a87308045d341e85584597bfe7426e9Nate Begeman case ISD::Constant: 1225368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // We know all of the bits for a constant! 122626c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola KnownOne = cast<ConstantSDNode>(Op)->getAPIntValue(); 122726c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola KnownZero = ~KnownOne; 1228ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return false; // Don't fall through, will infinitely loop. 1229de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman case ISD::AND: 123081cd35586f5b675faf5391e1f597908bdda5338eChris Lattner // If the RHS is a constant, check to see if the LHS would be zero without 123181cd35586f5b675faf5391e1f597908bdda5338eChris Lattner // using the bits from the RHS. Below, we use knowledge about the RHS to 123281cd35586f5b675faf5391e1f597908bdda5338eChris Lattner // simplify the LHS, here we're using information from the LHS to simplify 123381cd35586f5b675faf5391e1f597908bdda5338eChris Lattner // the RHS. 123481cd35586f5b675faf5391e1f597908bdda5338eChris Lattner if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(Op.getOperand(1))) { 12357b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt LHSZero, LHSOne; 123697fd9a58de3c99a74b0890a908430fa3ab894bedDale Johannesen // Do not increment Depth here; that can cause an infinite loop. 123726c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola TLO.DAG.ComputeMaskedBits(Op.getOperand(0), LHSZero, LHSOne, Depth); 123881cd35586f5b675faf5391e1f597908bdda5338eChris Lattner // If the LHS already has zeros where RHSC does, this and is dead. 12397b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((LHSZero & NewMask) == (~RHSC->getAPIntValue() & NewMask)) 124081cd35586f5b675faf5391e1f597908bdda5338eChris Lattner return TLO.CombineTo(Op, Op.getOperand(0)); 124181cd35586f5b675faf5391e1f597908bdda5338eChris Lattner // If any of the set bits in the RHS are known zero on the LHS, shrink 124281cd35586f5b675faf5391e1f597908bdda5338eChris Lattner // the constant. 12437b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (TLO.ShrinkDemandedConstant(Op, ~LHSZero & NewMask)) 124481cd35586f5b675faf5391e1f597908bdda5338eChris Lattner return true; 124581cd35586f5b675faf5391e1f597908bdda5338eChris Lattner } 1246bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 12477b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(1), NewMask, KnownZero, 1248368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne, TLO, Depth+1)) 1249368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1250bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 12517b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(0), ~KnownZero & NewMask, 1252368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero2, KnownOne2, TLO, Depth+1)) 1253368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1254bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?"); 1255bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1256368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If all of the demanded bits are known one on one side, return the other. 1257368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // These bits cannot contribute to the result of the 'and'. 12587b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & ~KnownZero2 & KnownOne) == (~KnownZero2 & NewMask)) 1259368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(0)); 12607b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & ~KnownZero & KnownOne2) == (~KnownZero & NewMask)) 1261368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(1)); 1262368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If all of the demanded bits in the inputs are known zeros, return zero. 12637b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & (KnownZero|KnownZero2)) == NewMask) 1264368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, TLO.DAG.getConstant(0, Op.getValueType())); 1265368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If the RHS is a constant, see if we can simplify it. 12667b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (TLO.ShrinkDemandedConstant(Op, ~KnownZero2 & NewMask)) 1267368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 126897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // If the operation can be done in a smaller type, do so. 12694e39e9da0f3a435445261d0f796bb0913f3c2bf0Dan Gohman if (TLO.ShrinkDemandedOp(Op, BitWidth, NewMask, dl)) 127097121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return true; 127197121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman 1272368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Output known-1 bits are only known if set in both the LHS & RHS. 1273368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne &= KnownOne2; 1274368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Output known-0 are known to be clear if zero in either the LHS | RHS. 1275368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero |= KnownZero2; 1276368e18d56a87308045d341e85584597bfe7426e9Nate Begeman break; 1277368e18d56a87308045d341e85584597bfe7426e9Nate Begeman case ISD::OR: 1278bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (SimplifyDemandedBits(Op.getOperand(1), NewMask, KnownZero, 1279368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne, TLO, Depth+1)) 1280368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1281bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 12827b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(0), ~KnownOne & NewMask, 1283368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero2, KnownOne2, TLO, Depth+1)) 1284368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1285bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?"); 1286bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1287368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If all of the demanded bits are known zero on one side, return the other. 1288368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // These bits cannot contribute to the result of the 'or'. 12897b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & ~KnownOne2 & KnownZero) == (~KnownOne2 & NewMask)) 1290368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(0)); 12917b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & ~KnownOne & KnownZero2) == (~KnownOne & NewMask)) 1292368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(1)); 1293368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If all of the potentially set bits on one side are known to be set on 1294368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // the other side, just use the 'other' side. 12957b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & ~KnownZero & KnownOne2) == (~KnownZero & NewMask)) 1296368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(0)); 12977b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & ~KnownZero2 & KnownOne) == (~KnownZero2 & NewMask)) 1298368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(1)); 1299368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If the RHS is a constant, see if we can simplify it. 13007b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (TLO.ShrinkDemandedConstant(Op, NewMask)) 1301368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 130297121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // If the operation can be done in a smaller type, do so. 13034e39e9da0f3a435445261d0f796bb0913f3c2bf0Dan Gohman if (TLO.ShrinkDemandedOp(Op, BitWidth, NewMask, dl)) 130497121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return true; 130597121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman 1306368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Output known-0 bits are only known if clear in both the LHS & RHS. 1307368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero &= KnownZero2; 1308368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Output known-1 are known to be set if set in either the LHS | RHS. 1309368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne |= KnownOne2; 1310368e18d56a87308045d341e85584597bfe7426e9Nate Begeman break; 1311368e18d56a87308045d341e85584597bfe7426e9Nate Begeman case ISD::XOR: 1312bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (SimplifyDemandedBits(Op.getOperand(1), NewMask, KnownZero, 1313368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne, TLO, Depth+1)) 1314368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1315bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 13167b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(0), NewMask, KnownZero2, 1317368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne2, TLO, Depth+1)) 1318368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1319bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?"); 1320bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1321368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If all of the demanded bits are known zero on one side, return the other. 1322368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // These bits cannot contribute to the result of the 'xor'. 13237b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((KnownZero & NewMask) == NewMask) 1324368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(0)); 13257b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((KnownZero2 & NewMask) == NewMask) 1326368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return TLO.CombineTo(Op, Op.getOperand(1)); 132797121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // If the operation can be done in a smaller type, do so. 13284e39e9da0f3a435445261d0f796bb0913f3c2bf0Dan Gohman if (TLO.ShrinkDemandedOp(Op, BitWidth, NewMask, dl)) 132997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return true; 133097121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman 13313687c1a4d3ecbe6709fddd77d79dc6b128d31431Chris Lattner // If all of the unknown bits are known to be zero on one side or the other 13323687c1a4d3ecbe6709fddd77d79dc6b128d31431Chris Lattner // (but not both) turn this into an *inclusive* or. 13333687c1a4d3ecbe6709fddd77d79dc6b128d31431Chris Lattner // e.g. (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0 13347b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & ~KnownZero & ~KnownZero2) == 0) 1335de06470330260f5937e7ca558f5f5b3e171f2ee5Dale Johannesen return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::OR, dl, Op.getValueType(), 13363687c1a4d3ecbe6709fddd77d79dc6b128d31431Chris Lattner Op.getOperand(0), 13373687c1a4d3ecbe6709fddd77d79dc6b128d31431Chris Lattner Op.getOperand(1))); 1338bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1339368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Output known-0 bits are known if clear or set in both the LHS & RHS. 1340368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZeroOut = (KnownZero & KnownZero2) | (KnownOne & KnownOne2); 1341368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Output known-1 are known to be set if set in only one of the LHS, RHS. 1342368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOneOut = (KnownZero & KnownOne2) | (KnownOne & KnownZero2); 1343bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1344368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If all of the demanded bits on one side are known, and all of the set 1345368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // bits on that side are also known to be set on the other side, turn this 1346368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // into an AND, as we know the bits will be cleared. 1347368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // e.g. (X | C1) ^ C2 --> (X | C1) & ~C2 iff (C1&C2) == C2 1348d16ce17711e8e6231363fe1fd47800570b75d61dJoel Jones // NB: it is okay if more bits are known than are requested 1349d16ce17711e8e6231363fe1fd47800570b75d61dJoel Jones if ((NewMask & (KnownZero|KnownOne)) == NewMask) { // all known on one side 1350d16ce17711e8e6231363fe1fd47800570b75d61dJoel Jones if (KnownOne == KnownOne2) { // set bits are the same on both sides 1351e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 1352475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ANDC = TLO.DAG.getConstant(~KnownOne & NewMask, VT); 1353bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::AND, dl, VT, 1354ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Op.getOperand(0), ANDC)); 1355368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } 1356de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman } 1357bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1358368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If the RHS is a constant, see if we can simplify it. 13594fea2e982d79132715711dfcfdc46abf15239217Torok Edwin // for XOR, we prefer to force bits to 1 if they will make a -1. 13604fea2e982d79132715711dfcfdc46abf15239217Torok Edwin // if we can't force bits, try to shrink constant 13614fea2e982d79132715711dfcfdc46abf15239217Torok Edwin if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) { 13624fea2e982d79132715711dfcfdc46abf15239217Torok Edwin APInt Expanded = C->getAPIntValue() | (~NewMask); 13634fea2e982d79132715711dfcfdc46abf15239217Torok Edwin // if we can expand it to have all bits set, do it 13644fea2e982d79132715711dfcfdc46abf15239217Torok Edwin if (Expanded.isAllOnesValue()) { 13654fea2e982d79132715711dfcfdc46abf15239217Torok Edwin if (Expanded != C->getAPIntValue()) { 1366e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 1367ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen SDValue New = TLO.DAG.getNode(Op.getOpcode(), dl,VT, Op.getOperand(0), 13684fea2e982d79132715711dfcfdc46abf15239217Torok Edwin TLO.DAG.getConstant(Expanded, VT)); 13694fea2e982d79132715711dfcfdc46abf15239217Torok Edwin return TLO.CombineTo(Op, New); 13704fea2e982d79132715711dfcfdc46abf15239217Torok Edwin } 13714fea2e982d79132715711dfcfdc46abf15239217Torok Edwin // if it already has all the bits set, nothing to change 13724fea2e982d79132715711dfcfdc46abf15239217Torok Edwin // but don't shrink either! 13734fea2e982d79132715711dfcfdc46abf15239217Torok Edwin } else if (TLO.ShrinkDemandedConstant(Op, NewMask)) { 13744fea2e982d79132715711dfcfdc46abf15239217Torok Edwin return true; 13754fea2e982d79132715711dfcfdc46abf15239217Torok Edwin } 13764fea2e982d79132715711dfcfdc46abf15239217Torok Edwin } 13774fea2e982d79132715711dfcfdc46abf15239217Torok Edwin 1378368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero = KnownZeroOut; 1379368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne = KnownOneOut; 1380368e18d56a87308045d341e85584597bfe7426e9Nate Begeman break; 1381368e18d56a87308045d341e85584597bfe7426e9Nate Begeman case ISD::SELECT: 1382bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (SimplifyDemandedBits(Op.getOperand(2), NewMask, KnownZero, 1383368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne, TLO, Depth+1)) 1384368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 13857b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(1), NewMask, KnownZero2, 1386368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne2, TLO, Depth+1)) 1387368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1388bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 1389bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?"); 1390bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1391368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If the operands are constants, see if we can simplify them. 13927b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (TLO.ShrinkDemandedConstant(Op, NewMask)) 1393368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1394bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1395368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Only known if known in both the LHS and RHS. 1396368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne &= KnownOne2; 1397368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero &= KnownZero2; 1398de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman break; 1399ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner case ISD::SELECT_CC: 1400bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (SimplifyDemandedBits(Op.getOperand(3), NewMask, KnownZero, 1401ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownOne, TLO, Depth+1)) 1402ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return true; 14037b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(2), NewMask, KnownZero2, 1404ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownOne2, TLO, Depth+1)) 1405ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return true; 1406bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 1407bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?"); 1408bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1409ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If the operands are constants, see if we can simplify them. 14107b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (TLO.ShrinkDemandedConstant(Op, NewMask)) 1411ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return true; 1412bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1413ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // Only known if known in both the LHS and RHS. 1414ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownOne &= KnownOne2; 1415ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownZero &= KnownZero2; 1416ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner break; 1417de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman case ISD::SHL: 1418368e18d56a87308045d341e85584597bfe7426e9Nate Begeman if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) { 1419f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned ShAmt = SA->getZExtValue(); 1420475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InOp = Op.getOperand(0); 1421895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner 14227b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman // If the shift count is an invalid immediate, don't do anything. 14237b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (ShAmt >= BitWidth) 14247b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman break; 14257b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman 1426895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner // If this is ((X >>u C1) << ShAmt), see if we can simplify this into a 1427895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner // single shift. We can do this if the bottom bits (which are shifted 1428895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner // out) are never demanded. 1429895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner if (InOp.getOpcode() == ISD::SRL && 1430895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner isa<ConstantSDNode>(InOp.getOperand(1))) { 14317b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (ShAmt && (NewMask & APInt::getLowBitsSet(BitWidth, ShAmt)) == 0) { 1432f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned C1= cast<ConstantSDNode>(InOp.getOperand(1))->getZExtValue(); 1433895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner unsigned Opc = ISD::SHL; 1434895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner int Diff = ShAmt-C1; 1435895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner if (Diff < 0) { 1436895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner Diff = -Diff; 1437895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner Opc = ISD::SRL; 1438bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 1439bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1440bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue NewSA = 14414e7e6cd13ab8cab410ad11375101878865579325Chris Lattner TLO.DAG.getConstant(Diff, Op.getOperand(1).getValueType()); 1442e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 1443ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, 1444895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner InOp.getOperand(0), NewSA)); 1445895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner } 1446bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 1447bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1448a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman if (SimplifyDemandedBits(InOp, NewMask.lshr(ShAmt), 1449368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero, KnownOne, TLO, Depth+1)) 1450368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1451a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman 1452a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman // Convert (shl (anyext x, c)) to (anyext (shl x, c)) if the high bits 1453a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman // are not demanded. This will likely allow the anyext to be folded away. 1454a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman if (InOp.getNode()->getOpcode() == ISD::ANY_EXTEND) { 1455a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman SDValue InnerOp = InOp.getNode()->getOperand(0); 1456a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman EVT InnerVT = InnerOp.getValueType(); 14572dd0353fec61b412e521013049d6a03de29aa8c7Eli Friedman unsigned InnerBits = InnerVT.getSizeInBits(); 14582dd0353fec61b412e521013049d6a03de29aa8c7Eli Friedman if (ShAmt < InnerBits && NewMask.lshr(InnerBits) == 0 && 1459a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman isTypeDesirableForOp(ISD::SHL, InnerVT)) { 146095771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson EVT ShTy = getShiftAmountTy(InnerVT); 1461cd20c6fb18230f399fc99276fbdee14ce9faf6a1Dan Gohman if (!APInt(BitWidth, ShAmt).isIntN(ShTy.getSizeInBits())) 1462cd20c6fb18230f399fc99276fbdee14ce9faf6a1Dan Gohman ShTy = InnerVT; 1463a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman SDValue NarrowShl = 1464a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman TLO.DAG.getNode(ISD::SHL, dl, InnerVT, InnerOp, 1465cd20c6fb18230f399fc99276fbdee14ce9faf6a1Dan Gohman TLO.DAG.getConstant(ShAmt, ShTy)); 1466a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman return 1467a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman TLO.CombineTo(Op, 1468a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman TLO.DAG.getNode(ISD::ANY_EXTEND, dl, Op.getValueType(), 1469a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman NarrowShl)); 1470a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman } 1471a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman } 1472a4f4d699ec627e798357929295aecd3d55b8d703Dan Gohman 1473f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman KnownZero <<= SA->getZExtValue(); 1474f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman KnownOne <<= SA->getZExtValue(); 14757b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman // low bits known zero. 1476f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman KnownZero |= APInt::getLowBitsSet(BitWidth, SA->getZExtValue()); 1477368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } 1478368e18d56a87308045d341e85584597bfe7426e9Nate Begeman break; 1479368e18d56a87308045d341e85584597bfe7426e9Nate Begeman case ISD::SRL: 1480368e18d56a87308045d341e85584597bfe7426e9Nate Begeman if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) { 1481e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 1482f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned ShAmt = SA->getZExtValue(); 148383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned VTSize = VT.getSizeInBits(); 1484475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InOp = Op.getOperand(0); 1485bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 14867b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman // If the shift count is an invalid immediate, don't do anything. 14877b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (ShAmt >= BitWidth) 14887b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman break; 14897b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman 1490895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner // If this is ((X << C1) >>u ShAmt), see if we can simplify this into a 1491895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner // single shift. We can do this if the top bits (which are shifted out) 1492895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner // are never demanded. 1493895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner if (InOp.getOpcode() == ISD::SHL && 1494895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner isa<ConstantSDNode>(InOp.getOperand(1))) { 14957b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (ShAmt && (NewMask & APInt::getHighBitsSet(VTSize, ShAmt)) == 0) { 1496f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned C1= cast<ConstantSDNode>(InOp.getOperand(1))->getZExtValue(); 1497895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner unsigned Opc = ISD::SRL; 1498895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner int Diff = ShAmt-C1; 1499895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner if (Diff < 0) { 1500895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner Diff = -Diff; 1501895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner Opc = ISD::SHL; 1502bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 1503bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1504475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue NewSA = 15058c7d2d56bf5aa2186e2d08ed1dc37c2f392b4aaeChris Lattner TLO.DAG.getConstant(Diff, Op.getOperand(1).getValueType()); 1506ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, 1507895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner InOp.getOperand(0), NewSA)); 1508895c4ab564c145d16a585201ea49b91541d806b6Chris Lattner } 1509bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 1510bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1511368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // Compute the new bits that are at the top now. 15127b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(InOp, (NewMask << ShAmt), 1513368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero, KnownOne, TLO, Depth+1)) 1514368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1515bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 15167b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman KnownZero = KnownZero.lshr(ShAmt); 15177b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman KnownOne = KnownOne.lshr(ShAmt); 1518c4fa603347e798c94f54430227df8265736ef183Chris Lattner 15197b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt HighBits = APInt::getHighBitsSet(BitWidth, ShAmt); 1520c4fa603347e798c94f54430227df8265736ef183Chris Lattner KnownZero |= HighBits; // High bits known zero. 1521368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } 1522368e18d56a87308045d341e85584597bfe7426e9Nate Begeman break; 1523368e18d56a87308045d341e85584597bfe7426e9Nate Begeman case ISD::SRA: 1524e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman // If this is an arithmetic shift right and only the low-bit is set, we can 1525e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman // always convert this into a logical shr, even if the shift amount is 1526e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman // variable. The low bit of the shift cannot be an input sign bit unless 1527e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman // the shift amount is >= the size of the datatype, which is undefined. 15282dd0353fec61b412e521013049d6a03de29aa8c7Eli Friedman if (NewMask == 1) 1529e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng return TLO.CombineTo(Op, 1530e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng TLO.DAG.getNode(ISD::SRL, dl, Op.getValueType(), 1531e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng Op.getOperand(0), Op.getOperand(1))); 1532e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman 1533368e18d56a87308045d341e85584597bfe7426e9Nate Begeman if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) { 1534e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 1535f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned ShAmt = SA->getZExtValue(); 1536bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 15377b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman // If the shift count is an invalid immediate, don't do anything. 15387b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (ShAmt >= BitWidth) 15397b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman break; 15407b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman 15417b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt InDemandedMask = (NewMask << ShAmt); 15421b7371331fef3db77999b9c4ca62c2ddbaf1d804Chris Lattner 15431b7371331fef3db77999b9c4ca62c2ddbaf1d804Chris Lattner // If any of the demanded bits are produced by the sign extension, we also 15441b7371331fef3db77999b9c4ca62c2ddbaf1d804Chris Lattner // demand the input sign bit. 15457b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt HighBits = APInt::getHighBitsSet(BitWidth, ShAmt); 15467b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (HighBits.intersects(NewMask)) 154787862e77bbf90cf1b68c9eea1f3641ad81435e38Dan Gohman InDemandedMask |= APInt::getSignBit(VT.getScalarType().getSizeInBits()); 1548bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 15491b7371331fef3db77999b9c4ca62c2ddbaf1d804Chris Lattner if (SimplifyDemandedBits(Op.getOperand(0), InDemandedMask, 1550368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero, KnownOne, TLO, Depth+1)) 1551368e18d56a87308045d341e85584597bfe7426e9Nate Begeman return true; 1552bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 15537b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman KnownZero = KnownZero.lshr(ShAmt); 15547b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman KnownOne = KnownOne.lshr(ShAmt); 1555bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 15567b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman // Handle the sign bit, adjusted to where it is now in the mask. 15577b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt SignBit = APInt::getSignBit(BitWidth).lshr(ShAmt); 1558bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1559368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If the input sign bit is known to be zero, or if none of the top bits 1560368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // are demanded, turn this into an unsigned shift right. 15617b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (KnownZero.intersects(SignBit) || (HighBits & ~NewMask) == HighBits) { 1562bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SRL, dl, VT, 1563ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Op.getOperand(0), 1564368e18d56a87308045d341e85584597bfe7426e9Nate Begeman Op.getOperand(1))); 15657b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman } else if (KnownOne.intersects(SignBit)) { // New bits are known one. 1566368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne |= HighBits; 1567368e18d56a87308045d341e85584597bfe7426e9Nate Begeman } 1568de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman } 1569de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman break; 1570de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman case ISD::SIGN_EXTEND_INREG: { 1571cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem EVT ExVT = cast<VTSDNode>(Op.getOperand(1))->getVT(); 1572cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem 1573cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem APInt MsbMask = APInt::getHighBitsSet(BitWidth, 1); 1574cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem // If we only care about the highest bit, don't bother shifting right. 1575d49db36badcfa29022b99325135c3ca429150be0Eli Friedman if (MsbMask == DemandedMask) { 1576cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem unsigned ShAmt = ExVT.getScalarType().getSizeInBits(); 1577cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem SDValue InOp = Op.getOperand(0); 1578d49db36badcfa29022b99325135c3ca429150be0Eli Friedman 1579d49db36badcfa29022b99325135c3ca429150be0Eli Friedman // Compute the correct shift amount type, which must be getShiftAmountTy 1580d49db36badcfa29022b99325135c3ca429150be0Eli Friedman // for scalar types after legalization. 1581d49db36badcfa29022b99325135c3ca429150be0Eli Friedman EVT ShiftAmtTy = Op.getValueType(); 1582d49db36badcfa29022b99325135c3ca429150be0Eli Friedman if (TLO.LegalTypes() && !ShiftAmtTy.isVector()) 1583d49db36badcfa29022b99325135c3ca429150be0Eli Friedman ShiftAmtTy = getShiftAmountTy(ShiftAmtTy); 1584d49db36badcfa29022b99325135c3ca429150be0Eli Friedman 1585d49db36badcfa29022b99325135c3ca429150be0Eli Friedman SDValue ShiftAmt = TLO.DAG.getConstant(BitWidth - ShAmt, ShiftAmtTy); 1586cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SHL, dl, 1587cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem Op.getValueType(), InOp, ShiftAmt)); 1588cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem } 1589368e18d56a87308045d341e85584597bfe7426e9Nate Begeman 1590bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // Sign extension. Compute the demanded bits in the result that are not 1591368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // present in the input. 1592d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman APInt NewBits = 1593d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman APInt::getHighBitsSet(BitWidth, 1594cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem BitWidth - ExVT.getScalarType().getSizeInBits()); 1595bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1596ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If none of the extended bits are demanded, eliminate the sextinreg. 15971d17d199a4cd6190fdf82e35c42b617eaae2cd35Eli Friedman if ((NewBits & NewMask) == 0) 1598ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return TLO.CombineTo(Op, Op.getOperand(0)); 1599ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner 160040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt InSignBit = 1601cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem APInt::getSignBit(ExVT.getScalarType().getSizeInBits()).zext(BitWidth); 1602d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman APInt InputDemandedBits = 1603d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman APInt::getLowBitsSet(BitWidth, 1604cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem ExVT.getScalarType().getSizeInBits()) & 1605d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman NewMask; 1606bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1607ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // Since the sign extended bits are demanded, we know that the sign 1608368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // bit is demanded. 1609ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner InputDemandedBits |= InSignBit; 1610368e18d56a87308045d341e85584597bfe7426e9Nate Begeman 1611368e18d56a87308045d341e85584597bfe7426e9Nate Begeman if (SimplifyDemandedBits(Op.getOperand(0), InputDemandedBits, 1612368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero, KnownOne, TLO, Depth+1)) 1613de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman return true; 1614bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 1615368e18d56a87308045d341e85584597bfe7426e9Nate Begeman 1616368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // If the sign bit of the input is known set or clear, then we know the 1617368e18d56a87308045d341e85584597bfe7426e9Nate Begeman // top bits of the result. 1618bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1619ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If the input sign bit is known zero, convert this into a zero extension. 16207b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (KnownZero.intersects(InSignBit)) 1621bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return TLO.CombineTo(Op, 1622cc6165695fa1713230184d743368b8b3642faa5dNadav Rotem TLO.DAG.getZeroExtendInReg(Op.getOperand(0),dl,ExVT)); 1623bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 16247b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (KnownOne.intersects(InSignBit)) { // Input sign bit known set 1625368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne |= NewBits; 1626368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero &= ~NewBits; 1627ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner } else { // Input sign bit unknown 1628368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownZero &= ~NewBits; 1629368e18d56a87308045d341e85584597bfe7426e9Nate Begeman KnownOne &= ~NewBits; 1630de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman } 1631de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman break; 1632de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman } 1633ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner case ISD::ZERO_EXTEND: { 1634d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman unsigned OperandBitWidth = 1635d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman Op.getOperand(0).getValueType().getScalarType().getSizeInBits(); 163640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt InMask = NewMask.trunc(OperandBitWidth); 1637bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1638ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If none of the top bits are demanded, convert this into an any_extend. 16397b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt NewBits = 16407b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt::getHighBitsSet(BitWidth, BitWidth - OperandBitWidth) & NewMask; 16417b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (!NewBits.intersects(NewMask)) 1642ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::ANY_EXTEND, dl, 1643bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Op.getValueType(), 1644ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner Op.getOperand(0))); 1645bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 16467b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(0), InMask, 1647ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownZero, KnownOne, TLO, Depth+1)) 1648ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return true; 1649bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 165040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownZero = KnownZero.zext(BitWidth); 165140f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownOne = KnownOne.zext(BitWidth); 1652ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownZero |= NewBits; 1653ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner break; 1654ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner } 1655ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner case ISD::SIGN_EXTEND: { 1656e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT InVT = Op.getOperand(0).getValueType(); 1657d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman unsigned InBits = InVT.getScalarType().getSizeInBits(); 16587b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt InMask = APInt::getLowBitsSet(BitWidth, InBits); 16599736028d84de3a72dd8db5f49cfaa07280154a0eDan Gohman APInt InSignBit = APInt::getBitsSet(BitWidth, InBits - 1, InBits); 16607b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt NewBits = ~InMask & NewMask; 1661bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1662ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If none of the top bits are demanded, convert this into an any_extend. 1663ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner if (NewBits == 0) 1664ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return TLO.CombineTo(Op,TLO.DAG.getNode(ISD::ANY_EXTEND, dl, 1665ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Op.getValueType(), 1666ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Op.getOperand(0))); 1667bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1668ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // Since some of the sign extended bits are demanded, we know that the sign 1669ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // bit is demanded. 16707b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman APInt InDemandedBits = InMask & NewMask; 1671ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner InDemandedBits |= InSignBit; 167240f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad InDemandedBits = InDemandedBits.trunc(InBits); 1673bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1674bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (SimplifyDemandedBits(Op.getOperand(0), InDemandedBits, KnownZero, 1675ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownOne, TLO, Depth+1)) 1676ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return true; 167740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownZero = KnownZero.zext(BitWidth); 167840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownOne = KnownOne.zext(BitWidth); 1679bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1680ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If the sign bit is known zero, convert this to a zero extend. 16817b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (KnownZero.intersects(InSignBit)) 1682ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::ZERO_EXTEND, dl, 1683bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Op.getValueType(), 1684ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner Op.getOperand(0))); 1685bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1686ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If the sign bit is known one, the top bits match. 16877b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (KnownOne.intersects(InSignBit)) { 168826c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola KnownOne |= NewBits; 168926c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola assert((KnownZero & NewBits) == 0); 1690ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner } else { // Otherwise, top bits aren't known. 169126c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola assert((KnownOne & NewBits) == 0); 169226c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola assert((KnownZero & NewBits) == 0); 1693ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner } 1694ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner break; 1695ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner } 1696ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner case ISD::ANY_EXTEND: { 1697d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman unsigned OperandBitWidth = 1698d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman Op.getOperand(0).getValueType().getScalarType().getSizeInBits(); 169940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt InMask = NewMask.trunc(OperandBitWidth); 17007b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(0), InMask, 1701ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownZero, KnownOne, TLO, Depth+1)) 1702ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return true; 1703bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 170440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownZero = KnownZero.zext(BitWidth); 170540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownOne = KnownOne.zext(BitWidth); 1706ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner break; 1707ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner } 1708fe8babf689c624c53d03f5629324b049b5327a6eChris Lattner case ISD::TRUNCATE: { 1709c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner // Simplify the input, using demanded bit information, and compute the known 1710c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner // zero/one bits live out. 1711042919c0c5f87f937e1a01ca548811af2f297e83Dan Gohman unsigned OperandBitWidth = 1712042919c0c5f87f937e1a01ca548811af2f297e83Dan Gohman Op.getOperand(0).getValueType().getScalarType().getSizeInBits(); 171340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt TruncMask = NewMask.zext(OperandBitWidth); 17147b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if (SimplifyDemandedBits(Op.getOperand(0), TruncMask, 1715fe8babf689c624c53d03f5629324b049b5327a6eChris Lattner KnownZero, KnownOne, TLO, Depth+1)) 1716fe8babf689c624c53d03f5629324b049b5327a6eChris Lattner return true; 171740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownZero = KnownZero.trunc(BitWidth); 171840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad KnownOne = KnownOne.trunc(BitWidth); 1719bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1720c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner // If the input is only used by this truncate, see if we can shrink it based 1721c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner // on the known demanded bits. 1722ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Op.getOperand(0).getNode()->hasOneUse()) { 1723475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue In = Op.getOperand(0); 1724c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner switch (In.getOpcode()) { 1725c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner default: break; 1726c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner case ISD::SRL: 1727c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner // Shrink SRL by a constant if none of the high bits shifted in are 1728c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner // demanded. 1729e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng if (TLO.LegalTypes() && 1730e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng !isTypeDesirableForOp(ISD::SRL, Op.getValueType())) 1731e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng // Do not turn (vt1 truncate (vt2 srl)) into (vt1 srl) if vt1 is 1732e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng // undesirable. 1733e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng break; 1734e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng ConstantSDNode *ShAmt = dyn_cast<ConstantSDNode>(In.getOperand(1)); 1735e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng if (!ShAmt) 1736e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng break; 17377adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson SDValue Shift = In.getOperand(1); 17387adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson if (TLO.LegalTypes()) { 17397adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson uint64_t ShVal = ShAmt->getZExtValue(); 17407adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson Shift = 17417adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson TLO.DAG.getConstant(ShVal, getShiftAmountTy(Op.getValueType())); 17427adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson } 17437adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson 1744e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng APInt HighBits = APInt::getHighBitsSet(OperandBitWidth, 1745e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng OperandBitWidth - BitWidth); 174640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad HighBits = HighBits.lshr(ShAmt->getZExtValue()).trunc(BitWidth); 1747e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng 1748e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng if (ShAmt->getZExtValue() < BitWidth && !(HighBits & NewMask)) { 1749e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng // None of the shifted in bits are needed. Add a truncate of the 1750e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng // shift input, then shift it. 1751e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng SDValue NewTrunc = TLO.DAG.getNode(ISD::TRUNCATE, dl, 1752bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Op.getValueType(), 1753e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng In.getOperand(0)); 1754e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SRL, dl, 1755e5b51ac7708402473f0a558f4aac74fab63d4f7eEvan Cheng Op.getValueType(), 1756bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck NewTrunc, 17577adf862eb24f7c6cbf12fbc9e3e8229f6f863b8aOwen Anderson Shift)); 1758c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner } 1759c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner break; 1760c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner } 1761c93dfda9056a83a81b07ad25ed567cc303893990Chris Lattner } 1762bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1763bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 1764fe8babf689c624c53d03f5629324b049b5327a6eChris Lattner break; 1765fe8babf689c624c53d03f5629324b049b5327a6eChris Lattner } 1766ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner case ISD::AssertZext: { 17677ab15f6d4b9b9fd03c8ab6327ac2b1b3c4b4d04bOwen Anderson // AssertZext demands all of the high bits, plus any of the low bits 17687ab15f6d4b9b9fd03c8ab6327ac2b1b3c4b4d04bOwen Anderson // demanded by its users. 17697ab15f6d4b9b9fd03c8ab6327ac2b1b3c4b4d04bOwen Anderson EVT VT = cast<VTSDNode>(Op.getOperand(1))->getVT(); 17707ab15f6d4b9b9fd03c8ab6327ac2b1b3c4b4d04bOwen Anderson APInt InMask = APInt::getLowBitsSet(BitWidth, 17717ab15f6d4b9b9fd03c8ab6327ac2b1b3c4b4d04bOwen Anderson VT.getSizeInBits()); 17727ab15f6d4b9b9fd03c8ab6327ac2b1b3c4b4d04bOwen Anderson if (SimplifyDemandedBits(Op.getOperand(0), ~InMask | NewMask, 1773ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner KnownZero, KnownOne, TLO, Depth+1)) 1774ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return true; 1775bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); 1776400f75cb5ed39ab4f071f78f6a26beefbc8a46f0Dan Gohman 17777b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman KnownZero |= ~InMask & NewMask; 1778ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner break; 1779ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner } 1780bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck case ISD::BITCAST: 178157f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings // If this is an FP->Int bitcast and if the sign bit is the only 178257f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings // thing demanded, turn this into a FGETSIGN. 1783ca072a39778933df4264ae393bd0ca797db59df6Eli Friedman if (!TLO.LegalOperations() && 1784ca072a39778933df4264ae393bd0ca797db59df6Eli Friedman !Op.getValueType().isVector() && 17850948f0acca745eef8db6922edfd8836f717396b4Eli Friedman !Op.getOperand(0).getValueType().isVector() && 17860c3e67860af417febb1fa9e870ece912a16085acNadav Rotem NewMask == APInt::getSignBit(Op.getValueType().getSizeInBits()) && 17870c3e67860af417febb1fa9e870ece912a16085acNadav Rotem Op.getOperand(0).getValueType().isFloatingPoint()) { 178857f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings bool OpVTLegal = isOperationLegalOrCustom(ISD::FGETSIGN, Op.getValueType()); 178957f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings bool i32Legal = isOperationLegalOrCustom(ISD::FGETSIGN, MVT::i32); 179057f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings if ((OpVTLegal || i32Legal) && Op.getValueType().isSimple()) { 179157f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings EVT Ty = OpVTLegal ? Op.getValueType() : MVT::i32; 17922ceb2cfa8e8580a7d080f5c6235ab133b97fb8fbChris Lattner // Make a FGETSIGN + SHL to move the sign bit into the appropriate 17932ceb2cfa8e8580a7d080f5c6235ab133b97fb8fbChris Lattner // place. We expect the SHL to be eliminated by other optimizations. 1794090bf19de6e7c75fbf34e753f5e0ad58cc2ca15cStuart Hastings SDValue Sign = TLO.DAG.getNode(ISD::FGETSIGN, dl, Ty, Op.getOperand(0)); 179557f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings unsigned OpVTSizeInBits = Op.getValueType().getSizeInBits(); 179657f1fde7fcda84a7e1d7490163fbad18c3755d40Stuart Hastings if (!OpVTLegal && OpVTSizeInBits > 32) 1797090bf19de6e7c75fbf34e753f5e0ad58cc2ca15cStuart Hastings Sign = TLO.DAG.getNode(ISD::ZERO_EXTEND, dl, Op.getValueType(), Sign); 179883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned ShVal = Op.getValueType().getSizeInBits()-1; 1799bdce3726e2131f053d05f07ff135684ad6f11d80Stuart Hastings SDValue ShAmt = TLO.DAG.getConstant(ShVal, Op.getValueType()); 18003dfc4b12229acafee5c69c5ee1673b08027f0438Stuart Hastings return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SHL, dl, 18013dfc4b12229acafee5c69c5ee1673b08027f0438Stuart Hastings Op.getValueType(), 18022ceb2cfa8e8580a7d080f5c6235ab133b97fb8fbChris Lattner Sign, ShAmt)); 18032ceb2cfa8e8580a7d080f5c6235ab133b97fb8fbChris Lattner } 18042ceb2cfa8e8580a7d080f5c6235ab133b97fb8fbChris Lattner } 18052ceb2cfa8e8580a7d080f5c6235ab133b97fb8fbChris Lattner break; 180697121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman case ISD::ADD: 180797121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman case ISD::MUL: 180897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman case ISD::SUB: { 180997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // Add, Sub, and Mul don't demand any bits in positions beyond that 181097121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // of the highest bit demanded of them. 181197121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman APInt LoMask = APInt::getLowBitsSet(BitWidth, 181297121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman BitWidth - NewMask.countLeadingZeros()); 181397121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman if (SimplifyDemandedBits(Op.getOperand(0), LoMask, KnownZero2, 181497121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman KnownOne2, TLO, Depth+1)) 181597121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return true; 181697121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman if (SimplifyDemandedBits(Op.getOperand(1), LoMask, KnownZero2, 181797121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman KnownOne2, TLO, Depth+1)) 181897121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return true; 181997121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // See if the operation should be performed at a smaller bit width. 18204e39e9da0f3a435445261d0f796bb0913f3c2bf0Dan Gohman if (TLO.ShrinkDemandedOp(Op, BitWidth, NewMask, dl)) 182197121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman return true; 182297121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman } 182397121ba2afb8d566ff1bf5c4e8fc5d4077940a7fDan Gohman // FALL THROUGH 182454eed371314af403ef8307b386b3b5b46c8aa6fbDan Gohman default: 18251482b5fc7affd691fbd8ece7808ddd4559ad20aeChris Lattner // Just use ComputeMaskedBits to compute output bits. 182626c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola TLO.DAG.ComputeMaskedBits(Op, KnownZero, KnownOne, Depth); 1827a6bc5a4d2138ea3cba90f5a794dd525228ec2c73Chris Lattner break; 1828de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman } 1829bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1830ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // If we know the value of all of the demanded bits, return this as a 1831ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner // constant. 18327b8d4a9eef4eb02e561227b50c9d119cea4e8860Dan Gohman if ((NewMask & (KnownZero|KnownOne)) == NewMask) 1833ec665151b891bf59d7c7c6cab180a978e2c20265Chris Lattner return TLO.CombineTo(Op, TLO.DAG.getConstant(KnownOne, Op.getValueType())); 1834bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 1835de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman return false; 1836de99629e2ae8cd7cc731328d2ad6ed6b8e759f2cNate Begeman} 1837c6fd6cd65c88ef1f11da43c11be0152cb69013a7Chris Lattner 1838bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck/// computeMaskedBitsForTargetNode - Determine which of the bits specified 1839bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck/// in Mask are known to be either zero or one and return them in the 1840368e18d56a87308045d341e85584597bfe7426e9Nate Begeman/// KnownZero/KnownOne bitsets. 1841bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckvoid TargetLowering::computeMaskedBitsForTargetNode(const SDValue Op, 1842bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck APInt &KnownZero, 1843fd29e0eb060ea8b4d490860329234d2ae5f5952eDan Gohman APInt &KnownOne, 1844ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman const SelectionDAG &DAG, 1845368e18d56a87308045d341e85584597bfe7426e9Nate Begeman unsigned Depth) const { 18461b5232a93767eac1424c67fb86580deef97e21e0Chris Lattner assert((Op.getOpcode() >= ISD::BUILTIN_OP_END || 18471b5232a93767eac1424c67fb86580deef97e21e0Chris Lattner Op.getOpcode() == ISD::INTRINSIC_WO_CHAIN || 18481b5232a93767eac1424c67fb86580deef97e21e0Chris Lattner Op.getOpcode() == ISD::INTRINSIC_W_CHAIN || 18491b5232a93767eac1424c67fb86580deef97e21e0Chris Lattner Op.getOpcode() == ISD::INTRINSIC_VOID) && 1850c6fd6cd65c88ef1f11da43c11be0152cb69013a7Chris Lattner "Should use MaskedValueIsZero if you don't know whether Op" 1851c6fd6cd65c88ef1f11da43c11be0152cb69013a7Chris Lattner " is a target node!"); 185226c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola KnownZero = KnownOne = APInt(KnownOne.getBitWidth(), 0); 18533a03ebb37747c2b3fd9b4f8b44f1124f53727894Evan Cheng} 18544ccb070f158b0f331c68de800c6bab8c31c2ecb6Chris Lattner 18555c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner/// ComputeNumSignBitsForTargetNode - This method can be implemented by 18565c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner/// targets that want to expose additional information about sign bits to the 18575c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner/// DAG Combiner. 1858475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanunsigned TargetLowering::ComputeNumSignBitsForTargetNode(SDValue Op, 18595c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner unsigned Depth) const { 18605c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner assert((Op.getOpcode() >= ISD::BUILTIN_OP_END || 18615c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner Op.getOpcode() == ISD::INTRINSIC_WO_CHAIN || 18625c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner Op.getOpcode() == ISD::INTRINSIC_W_CHAIN || 18635c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner Op.getOpcode() == ISD::INTRINSIC_VOID) && 18645c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner "Should use ComputeNumSignBits if you don't know whether Op" 18655c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner " is a target node!"); 18665c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner return 1; 18675c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner} 18685c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner 186997d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman/// ValueHasExactlyOneBitSet - Test if the given value is known to have exactly 187097d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman/// one bit set. This differs from ComputeMaskedBits in that it doesn't need to 187197d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman/// determine which bit is set. 187297d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman/// 187385b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesenstatic bool ValueHasExactlyOneBitSet(SDValue Val, const SelectionDAG &DAG) { 187497d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman // A left-shift of a constant one will have exactly one bit set, because 187597d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman // shifting the bit off the end is undefined. 187697d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman if (Val.getOpcode() == ISD::SHL) 187797d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman if (ConstantSDNode *C = 187897d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman dyn_cast<ConstantSDNode>(Val.getNode()->getOperand(0))) 187997d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman if (C->getAPIntValue() == 1) 188097d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman return true; 188197d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman 188297d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman // Similarly, a right-shift of a constant sign-bit will have exactly 188397d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman // one bit set. 188497d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman if (Val.getOpcode() == ISD::SRL) 188597d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman if (ConstantSDNode *C = 188697d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman dyn_cast<ConstantSDNode>(Val.getNode()->getOperand(0))) 188797d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman if (C->getAPIntValue().isSignBit()) 188897d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman return true; 188997d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman 189097d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman // More could be done here, though the above checks are enough 189197d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman // to handle some common cases. 1892e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman 189397d116346cdf47ce0c8536a69ff6c606309cb4c0Dan Gohman // Fall back to ComputeMaskedBits to catch other known cases. 1894e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OpVT = Val.getValueType(); 18955b870aff81da0c07413f0241087bb3722954b83dDan Gohman unsigned BitWidth = OpVT.getScalarType().getSizeInBits(); 1896e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman APInt KnownZero, KnownOne; 189726c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola DAG.ComputeMaskedBits(Val, KnownZero, KnownOne); 189885b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesen return (KnownZero.countPopulation() == BitWidth - 1) && 189985b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesen (KnownOne.countPopulation() == 1); 1900e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman} 19015c3e21d68726dbfc313d8af3d320b0a6b3eeac36Chris Lattner 1902bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck/// SimplifySetCC - Try to simplify a setcc built with the specified operands 1903475871a144eb604ddaf37503397ba0941442e5fbDan Gohman/// and cc. If it is unable to simplify it, return a null SDValue. 1904475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue 1905e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonTargetLowering::SimplifySetCC(EVT VT, SDValue N0, SDValue N1, 1906fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng ISD::CondCode Cond, bool foldBooleans, 1907ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen DAGCombinerInfo &DCI, DebugLoc dl) const { 1908fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng SelectionDAG &DAG = DCI.DAG; 1909fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 1910fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // These setcc operations always fold. 1911fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng switch (Cond) { 1912fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng default: break; 1913fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETFALSE: 1914fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETFALSE2: return DAG.getConstant(0, VT); 1915fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETTRUE: 1916fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETTRUE2: return DAG.getConstant(1, VT); 1917fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 1918fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 19197a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // Ensure that the constant occurs on the RHS, and fold constant 19207a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // comparisons. 19217a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner if (isa<ConstantSDNode>(N0.getNode())) 1922b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, N1, N0, ISD::getSetCCSwappedOperands(Cond)); 1923362fee90b9a1d64ac091755466caf6a94ade22ebEric Christopher 1924ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode())) { 19256c6cd1ccb5de1ebab7089c8ce339889f33fa2577Dan Gohman const APInt &C1 = N1C->getAPIntValue(); 1926b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 1927b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If the LHS is '(srl (ctlz x), 5)', the RHS is 0/1, and this is an 1928b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // equality comparison, then we're just comparing whether X itself is 1929b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // zero. 1930b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (N0.getOpcode() == ISD::SRL && (C1 == 0 || C1 == 1) && 1931b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(0).getOpcode() == ISD::CTLZ && 1932b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(1).getOpcode() == ISD::Constant) { 1933347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng const APInt &ShAmt 1934347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue(); 1935b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETEQ || Cond == ISD::SETNE) && 1936b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ShAmt == Log2_32(N0.getValueType().getSizeInBits())) { 1937b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((C1 == 0) == (Cond == ISD::SETEQ)) { 1938b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // (srl (ctlz x), 5) == 0 -> X != 0 1939b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // (srl (ctlz x), 5) != 1 -> X != 0 1940b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Cond = ISD::SETNE; 1941b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } else { 1942b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // (srl (ctlz x), 5) != 0 -> X == 0 1943b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // (srl (ctlz x), 5) == 1 -> X == 0 1944b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Cond = ISD::SETEQ; 1945fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 1946b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman SDValue Zero = DAG.getConstant(0, N0.getValueType()); 1947b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, N0.getOperand(0).getOperand(0), 1948b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Zero, Cond); 1949fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 1950b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 195189217a6f1852e764e58c489872b2d155dc2b7b8bDale Johannesen 1952d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer SDValue CTPOP = N0; 1953d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer // Look through truncs that don't change the value of a ctpop. 1954d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer if (N0.hasOneUse() && N0.getOpcode() == ISD::TRUNCATE) 1955d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer CTPOP = N0.getOperand(0); 1956d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer 1957d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer if (CTPOP.hasOneUse() && CTPOP.getOpcode() == ISD::CTPOP && 1958c9b6a3eb90c5e0f6460632a443591068522537e2Benjamin Kramer (N0 == CTPOP || N0.getValueType().getSizeInBits() > 1959d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer Log2_32_Ceil(CTPOP.getValueType().getSizeInBits()))) { 1960d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer EVT CTVT = CTPOP.getValueType(); 1961d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer SDValue CTOp = CTPOP.getOperand(0); 1962d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer 1963d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer // (ctpop x) u< 2 -> (x & x-1) == 0 1964d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer // (ctpop x) u> 1 -> (x & x-1) != 0 1965d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer if ((Cond == ISD::SETULT && C1 == 2) || (Cond == ISD::SETUGT && C1 == 1)){ 1966d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer SDValue Sub = DAG.getNode(ISD::SUB, dl, CTVT, CTOp, 1967d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer DAG.getConstant(1, CTVT)); 1968d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer SDValue And = DAG.getNode(ISD::AND, dl, CTVT, CTOp, Sub); 1969d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer ISD::CondCode CC = Cond == ISD::SETULT ? ISD::SETEQ : ISD::SETNE; 1970d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer return DAG.getSetCC(dl, VT, And, DAG.getConstant(0, CTVT), CC); 1971d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer } 1972d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer 1973d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer // TODO: (ctpop x) == 1 -> x && (x & x-1) == 0 iff ctpop is illegal. 1974d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer } 1975d8228924556d3c465da5b858c620b29fd1cf298eBenjamin Kramer 1976e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer // (zext x) == C --> x == (trunc C) 1977e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer if (DCI.isBeforeLegalize() && N0->hasOneUse() && 1978e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer (Cond == ISD::SETEQ || Cond == ISD::SETNE)) { 1979e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer unsigned MinBits = N0.getValueSizeInBits(); 1980e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer SDValue PreZExt; 1981e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer if (N0->getOpcode() == ISD::ZERO_EXTEND) { 1982e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer // ZExt 1983e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer MinBits = N0->getOperand(0).getValueSizeInBits(); 1984e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer PreZExt = N0->getOperand(0); 1985e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } else if (N0->getOpcode() == ISD::AND) { 1986e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer // DAGCombine turns costly ZExts into ANDs 1987e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0->getOperand(1))) 1988e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer if ((C->getAPIntValue()+1).isPowerOf2()) { 1989e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer MinBits = C->getAPIntValue().countTrailingOnes(); 1990e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer PreZExt = N0->getOperand(0); 1991e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } 1992e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } else if (LoadSDNode *LN0 = dyn_cast<LoadSDNode>(N0)) { 1993e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer // ZEXTLOAD 1994e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer if (LN0->getExtensionType() == ISD::ZEXTLOAD) { 1995e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer MinBits = LN0->getMemoryVT().getSizeInBits(); 1996e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer PreZExt = N0; 1997e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } 1998e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } 1999e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer 2000d9b0b025612992a0b724eeca8bdf10b1d7a5c355Benjamin Kramer // Make sure we're not losing bits from the constant. 2001e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer if (MinBits < C1.getBitWidth() && MinBits > C1.getActiveBits()) { 2002e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer EVT MinVT = EVT::getIntegerVT(*DAG.getContext(), MinBits); 2003e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer if (isTypeDesirableForOp(ISD::SETCC, MinVT)) { 2004e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer // Will get folded away. 2005e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, MinVT, PreZExt); 2006e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer SDValue C = DAG.getConstant(C1.trunc(MinBits), MinVT); 2007e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer return DAG.getSetCC(dl, VT, Trunc, C, Cond); 2008e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } 2009e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } 2010e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer } 2011e7cf062537e898f830565db5dbf99ae9c928399eBenjamin Kramer 2012b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If the LHS is '(and load, const)', the RHS is 0, 2013b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // the test is for equality or unsigned, and all 1 bits of the const are 2014b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // in the same partial word, see if we can shorten the load. 2015b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (DCI.isBeforeLegalize() && 2016b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOpcode() == ISD::AND && C1 == 0 && 2017b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getNode()->hasOneUse() && 2018b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman isa<LoadSDNode>(N0.getOperand(0)) && 2019b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(0).getNode()->hasOneUse() && 2020b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman isa<ConstantSDNode>(N0.getOperand(1))) { 2021b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman LoadSDNode *Lod = cast<LoadSDNode>(N0.getOperand(0)); 2022347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng APInt bestMask; 2023b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned bestWidth = 0, bestOffset = 0; 2024347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng if (!Lod->isVolatile() && Lod->isUnindexed()) { 2025b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned origWidth = N0.getValueType().getSizeInBits(); 2026347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng unsigned maskWidth = origWidth; 2027bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // We can narrow (e.g.) 16-bit extending loads on 32-bit target to 2028b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // 8 bits, but have to be careful... 2029b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (Lod->getExtensionType() != ISD::NON_EXTLOAD) 2030b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman origWidth = Lod->getMemoryVT().getSizeInBits(); 2031347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng const APInt &Mask = 2032347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue(); 2033b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman for (unsigned width = origWidth / 2; width>=8; width /= 2) { 2034347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng APInt newMask = APInt::getLowBitsSet(maskWidth, width); 2035b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman for (unsigned offset=0; offset<origWidth/width; offset++) { 2036b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((newMask & Mask) == Mask) { 2037b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (!TD->isLittleEndian()) 2038b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman bestOffset = (origWidth/width - offset - 1) * (width/8); 2039b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman else 2040b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman bestOffset = (uint64_t)offset * (width/8); 2041347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng bestMask = Mask.lshr(offset * (width/8) * 8); 2042b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman bestWidth = width; 2043b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman break; 204489217a6f1852e764e58c489872b2d155dc2b7b8bDale Johannesen } 2045b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman newMask = newMask << width; 204689217a6f1852e764e58c489872b2d155dc2b7b8bDale Johannesen } 204789217a6f1852e764e58c489872b2d155dc2b7b8bDale Johannesen } 2048b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2049b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (bestWidth) { 2050c0c7fca2fedd2259569b7b84338259c62d38802dChris Lattner EVT newVT = EVT::getIntegerVT(*DAG.getContext(), bestWidth); 2051b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (newVT.isRound()) { 2052e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT PtrType = Lod->getOperand(1).getValueType(); 2053b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman SDValue Ptr = Lod->getBasePtr(); 2054b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (bestOffset != 0) 2055b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Ptr = DAG.getNode(ISD::ADD, dl, PtrType, Lod->getBasePtr(), 2056b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(bestOffset, PtrType)); 2057b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned NewAlign = MinAlign(Lod->getAlignment(), bestOffset); 2058b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman SDValue NewLoad = DAG.getLoad(newVT, dl, Lod->getChain(), Ptr, 2059ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Lod->getPointerInfo().getWithOffset(bestOffset), 2060d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, NewAlign); 2061bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, 2062b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getNode(ISD::AND, dl, newVT, NewLoad, 2063347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng DAG.getConstant(bestMask.trunc(bestWidth), 2064347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng newVT)), 2065b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(0LL, newVT), Cond); 206689217a6f1852e764e58c489872b2d155dc2b7b8bDale Johannesen } 206789217a6f1852e764e58c489872b2d155dc2b7b8bDale Johannesen } 2068b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2069d0ab34bf8feb7633b70158b571425577670b6326Bill Wendling 2070b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If the LHS is a ZERO_EXTEND, perform the comparison on the input. 2071b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (N0.getOpcode() == ISD::ZERO_EXTEND) { 2072b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned InSize = N0.getOperand(0).getValueType().getSizeInBits(); 2073fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2074b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If the comparison constant has bits in the upper part, the 2075b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // zero-extended value could never match. 2076b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (C1.intersects(APInt::getHighBitsSet(C1.getBitWidth(), 2077b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman C1.getBitWidth() - InSize))) { 2078fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng switch (Cond) { 2079fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETUGT: 2080fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETUGE: 2081b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETEQ: return DAG.getConstant(0, VT); 2082fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETULT: 2083b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETULE: 2084b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETNE: return DAG.getConstant(1, VT); 2085b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETGT: 2086b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETGE: 2087b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // True if the sign bit of C1 is set. 2088b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getConstant(C1.isNegative(), VT); 2089b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETLT: 2090b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETLE: 2091b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // True if the sign bit of C1 isn't set. 2092b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getConstant(C1.isNonNegative(), VT); 2093fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng default: 2094b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman break; 2095fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2096fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2097b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2098b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Otherwise, we can perform the comparison with the low bits. 2099b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman switch (Cond) { 2100b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETEQ: 2101b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETNE: 2102b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETUGT: 2103b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETUGE: 2104b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETULT: 2105b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman case ISD::SETULE: { 2106e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT newVT = N0.getOperand(0).getValueType(); 2107b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (DCI.isBeforeLegalizeOps() || 2108b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman (isOperationLegal(ISD::SETCC, newVT) && 2109b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman getCondCodeAction(Cond, newVT)==Legal)) 2110b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, N0.getOperand(0), 211140f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad DAG.getConstant(C1.trunc(InSize), newVT), 2112b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Cond); 2113b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman break; 2114b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2115b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman default: 2116b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman break; // todo, be more careful with signed comparisons 2117b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2118b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } else if (N0.getOpcode() == ISD::SIGN_EXTEND_INREG && 21192c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng (Cond == ISD::SETEQ || Cond == ISD::SETNE)) { 2120e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT ExtSrcTy = cast<VTSDNode>(N0.getOperand(1))->getVT(); 2121b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned ExtSrcTyBits = ExtSrcTy.getSizeInBits(); 2122e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT ExtDstTy = N0.getValueType(); 2123b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned ExtDstTyBits = ExtDstTy.getSizeInBits(); 2124b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2125ad78a88711979aa84a89a32576b615ff13b3de15Eli Friedman // If the constant doesn't fit into the number of bits for the source of 2126ad78a88711979aa84a89a32576b615ff13b3de15Eli Friedman // the sign extension, it is impossible for both sides to be equal. 2127ad78a88711979aa84a89a32576b615ff13b3de15Eli Friedman if (C1.getMinSignedBits() > ExtSrcTyBits) 2128b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getConstant(Cond == ISD::SETNE, VT); 2129bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2130b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman SDValue ZextOp; 2131e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT Op0Ty = N0.getOperand(0).getValueType(); 2132b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (Op0Ty == ExtSrcTy) { 2133b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ZextOp = N0.getOperand(0); 2134fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } else { 2135b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman APInt Imm = APInt::getLowBitsSet(ExtDstTyBits, ExtSrcTyBits); 2136b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ZextOp = DAG.getNode(ISD::AND, dl, Op0Ty, N0.getOperand(0), 2137b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(Imm, Op0Ty)); 2138fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2139b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (!DCI.isCalledByLegalizer()) 2140b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DCI.AddToWorklist(ZextOp.getNode()); 2141b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Otherwise, make this a use of a zext. 2142bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, ZextOp, 2143b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(C1 & APInt::getLowBitsSet( 2144b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ExtDstTyBits, 2145bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ExtSrcTyBits), 2146b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ExtDstTy), 2147b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Cond); 2148b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } else if ((N1C->isNullValue() || N1C->getAPIntValue() == 1) && 2149b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman (Cond == ISD::SETEQ || Cond == ISD::SETNE)) { 2150b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // SETCC (SETCC), [0|1], [EQ|NE] -> SETCC 21512c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng if (N0.getOpcode() == ISD::SETCC && 21522c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng isTypeLegal(VT) && VT.bitsLE(N0.getValueType())) { 2153347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng bool TrueWhenTrue = (Cond == ISD::SETEQ) ^ (N1C->getAPIntValue() != 1); 2154b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (TrueWhenTrue) 2155bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getNode(ISD::TRUNCATE, dl, VT, N0); 2156b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Invert the condition. 2157b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ISD::CondCode CC = cast<CondCodeSDNode>(N0.getOperand(2))->get(); 2158bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck CC = ISD::getSetCCInverse(CC, 2159b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(0).getValueType().isInteger()); 2160b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, N0.getOperand(0), N0.getOperand(1), CC); 2161fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 21622c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng 2163b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((N0.getOpcode() == ISD::XOR || 2164bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck (N0.getOpcode() == ISD::AND && 2165b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(0).getOpcode() == ISD::XOR && 2166b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(1) == N0.getOperand(0).getOperand(1))) && 2167b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman isa<ConstantSDNode>(N0.getOperand(1)) && 2168b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue() == 1) { 2169b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If this is (X^1) == 0/1, swap the RHS and eliminate the xor. We 2170b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // can only do this if the top bits are known zero. 2171b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned BitWidth = N0.getValueSizeInBits(); 2172b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (DAG.MaskedValueIsZero(N0, 2173b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman APInt::getHighBitsSet(BitWidth, 2174b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman BitWidth-1))) { 2175b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Okay, get the un-inverted input value. 2176b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman SDValue Val; 2177b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (N0.getOpcode() == ISD::XOR) 2178b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Val = N0.getOperand(0); 2179b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman else { 2180bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck assert(N0.getOpcode() == ISD::AND && 2181b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(0).getOpcode() == ISD::XOR); 2182b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // ((X^1)&1)^1 -> X & 1 2183b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Val = DAG.getNode(ISD::AND, dl, N0.getValueType(), 2184b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(0).getOperand(0), 2185b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N0.getOperand(1)); 2186b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 21872c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng 2188b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, Val, N1, 2189b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman Cond == ISD::SETEQ ? ISD::SETNE : ISD::SETEQ); 2190b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 21912c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng } else if (N1C->getAPIntValue() == 1 && 21922c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng (VT == MVT::i1 || 219328b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands getBooleanContents(false) == ZeroOrOneBooleanContent)) { 21942c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng SDValue Op0 = N0; 21952c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng if (Op0.getOpcode() == ISD::TRUNCATE) 21962c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng Op0 = Op0.getOperand(0); 21972c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng 21982c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng if ((Op0.getOpcode() == ISD::XOR) && 21992c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng Op0.getOperand(0).getOpcode() == ISD::SETCC && 22002c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng Op0.getOperand(1).getOpcode() == ISD::SETCC) { 22012c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng // (xor (setcc), (setcc)) == / != 1 -> (setcc) != / == (setcc) 22022c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng Cond = (Cond == ISD::SETEQ) ? ISD::SETNE : ISD::SETEQ; 22032c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng return DAG.getSetCC(dl, VT, Op0.getOperand(0), Op0.getOperand(1), 22042c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng Cond); 22052c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng } else if (Op0.getOpcode() == ISD::AND && 22062c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng isa<ConstantSDNode>(Op0.getOperand(1)) && 22072c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng cast<ConstantSDNode>(Op0.getOperand(1))->getAPIntValue() == 1) { 22082c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng // If this is (X&1) == / != 1, normalize it to (X&1) != / == 0. 220917458a786e4d3eeff9c66fc0ec284b763df53642Anton Korobeynikov if (Op0.getValueType().bitsGT(VT)) 22102c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng Op0 = DAG.getNode(ISD::AND, dl, VT, 22112c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng DAG.getNode(ISD::TRUNCATE, dl, VT, Op0.getOperand(0)), 22122c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng DAG.getConstant(1, VT)); 221317458a786e4d3eeff9c66fc0ec284b763df53642Anton Korobeynikov else if (Op0.getValueType().bitsLT(VT)) 221417458a786e4d3eeff9c66fc0ec284b763df53642Anton Korobeynikov Op0 = DAG.getNode(ISD::AND, dl, VT, 221517458a786e4d3eeff9c66fc0ec284b763df53642Anton Korobeynikov DAG.getNode(ISD::ANY_EXTEND, dl, VT, Op0.getOperand(0)), 221617458a786e4d3eeff9c66fc0ec284b763df53642Anton Korobeynikov DAG.getConstant(1, VT)); 221717458a786e4d3eeff9c66fc0ec284b763df53642Anton Korobeynikov 22182c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng return DAG.getSetCC(dl, VT, Op0, 22192c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng DAG.getConstant(0, Op0.getValueType()), 22202c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng Cond == ISD::SETEQ ? ISD::SETNE : ISD::SETEQ); 22212c755ba12a79e0bb2899c0bde00b2f7ea2c975a0Evan Cheng } 2222fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2223b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2224bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2225b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman APInt MinVal, MaxVal; 2226b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman unsigned OperandBitSize = N1C->getValueType(0).getSizeInBits(); 2227b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (ISD::isSignedIntSetCC(Cond)) { 2228b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman MinVal = APInt::getSignedMinValue(OperandBitSize); 2229b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman MaxVal = APInt::getSignedMaxValue(OperandBitSize); 2230b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } else { 2231b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman MinVal = APInt::getMinValue(OperandBitSize); 2232b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman MaxVal = APInt::getMaxValue(OperandBitSize); 2233b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2234fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2235b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Canonicalize GE/LE comparisons to use GT/LT comparisons. 2236b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (Cond == ISD::SETGE || Cond == ISD::SETUGE) { 2237b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (C1 == MinVal) return DAG.getConstant(1, VT); // X >= MIN --> true 2238b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // X >= C0 --> X > (C0-1) 2239bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, N0, 2240b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(C1-1, N1.getValueType()), 2241b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman (Cond == ISD::SETGE) ? ISD::SETGT : ISD::SETUGT); 2242b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2243fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2244b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (Cond == ISD::SETLE || Cond == ISD::SETULE) { 2245b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (C1 == MaxVal) return DAG.getConstant(1, VT); // X <= MAX --> true 2246b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // X <= C0 --> X < (C0+1) 2247bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, N0, 2248b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(C1+1, N1.getValueType()), 2249b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman (Cond == ISD::SETLE) ? ISD::SETLT : ISD::SETULT); 2250b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2251b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2252b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETLT || Cond == ISD::SETULT) && C1 == MinVal) 2253b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getConstant(0, VT); // X < MIN --> false 2254b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETGE || Cond == ISD::SETUGE) && C1 == MinVal) 2255b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getConstant(1, VT); // X >= MIN --> true 2256b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETGT || Cond == ISD::SETUGT) && C1 == MaxVal) 2257b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getConstant(0, VT); // X > MAX --> false 2258b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETLE || Cond == ISD::SETULE) && C1 == MaxVal) 2259b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getConstant(1, VT); // X <= MAX --> true 2260b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2261b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Canonicalize setgt X, Min --> setne X, Min 2262b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETGT || Cond == ISD::SETUGT) && C1 == MinVal) 2263b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETNE); 2264b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Canonicalize setlt X, Max --> setne X, Max 2265b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETLT || Cond == ISD::SETULT) && C1 == MaxVal) 2266b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETNE); 2267b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2268b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If we have setult X, 1, turn it into seteq X, 0 2269b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETLT || Cond == ISD::SETULT) && C1 == MinVal+1) 2270bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, N0, 2271bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck DAG.getConstant(MinVal, N0.getValueType()), 2272b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ISD::SETEQ); 2273b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If we have setugt X, Max-1, turn it into seteq X, Max 2274b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman else if ((Cond == ISD::SETGT || Cond == ISD::SETUGT) && C1 == MaxVal-1) 2275bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, N0, 2276b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(MaxVal, N0.getValueType()), 2277b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ISD::SETEQ); 2278b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2279b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // If we have "setcc X, C0", check to see if we can shrink the immediate 2280b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // by changing cc. 2281b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2282b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // SETUGT X, SINTMAX -> SETLT X, 0 2283bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (Cond == ISD::SETUGT && 2284b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman C1 == APInt::getSignedMaxValue(OperandBitSize)) 2285bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, N0, 2286b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(0, N1.getValueType()), 2287b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman ISD::SETLT); 2288b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2289b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // SETULT X, SINTMIN -> SETGT X, -1 2290b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (Cond == ISD::SETULT && 2291b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman C1 == APInt::getSignedMinValue(OperandBitSize)) { 2292b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman SDValue ConstMinusOne = 2293b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman DAG.getConstant(APInt::getAllOnesValue(OperandBitSize), 2294b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman N1.getValueType()); 2295b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman return DAG.getSetCC(dl, VT, N0, ConstMinusOne, ISD::SETGT); 2296b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2297b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman 2298b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Fold bit comparisons when we can. 2299b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if ((Cond == ISD::SETEQ || Cond == ISD::SETNE) && 2300d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng (VT == N0.getValueType() || 2301d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng (isTypeLegal(VT) && VT.bitsLE(N0.getValueType()))) && 2302d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng N0.getOpcode() == ISD::AND) 2303b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (ConstantSDNode *AndRHS = 2304b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman dyn_cast<ConstantSDNode>(N0.getOperand(1))) { 2305b97cebdfcc4d76835961038b79e605b167bd8cc5Benjamin Kramer EVT ShiftTy = DCI.isBeforeLegalizeOps() ? 230695771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson getPointerTy() : getShiftAmountTy(N0.getValueType()); 2307b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (Cond == ISD::SETNE && C1 == 0) {// (X & 8) != 0 --> (X & 8) >> 3 2308b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Perform the xform if the AND RHS is a single bit. 2309347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng if (AndRHS->getAPIntValue().isPowerOf2()) { 2310d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng return DAG.getNode(ISD::TRUNCATE, dl, VT, 2311d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng DAG.getNode(ISD::SRL, dl, N0.getValueType(), N0, 2312347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng DAG.getConstant(AndRHS->getAPIntValue().logBase2(), ShiftTy))); 2313b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 2314347a9cb5070be6473a5f881dd29997b46081d23bEvan Cheng } else if (Cond == ISD::SETEQ && C1 == AndRHS->getAPIntValue()) { 2315b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // (X & 8) == 8 --> (X & 8) >> 3 2316b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman // Perform the xform if C1 is a single bit. 2317b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman if (C1.isPowerOf2()) { 2318d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng return DAG.getNode(ISD::TRUNCATE, dl, VT, 2319d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng DAG.getNode(ISD::SRL, dl, N0.getValueType(), N0, 2320d40d03e1bd1d51857fc2f9f9230e334c3a32b249Evan Cheng DAG.getConstant(C1.logBase2(), ShiftTy))); 2321fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2322fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2323b101b0bdbd22fa1bef3502fd7521da60038ac333Eli Friedman } 232470e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng 2325b4d4959fdda7afdf7994d3cb0b20c052ad0c7895Evan Cheng if (C1.getMinSignedBits() <= 64 && 2326b4d4959fdda7afdf7994d3cb0b20c052ad0c7895Evan Cheng !isLegalICmpImmediate(C1.getSExtValue())) { 232770e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng // (X & -256) == 256 -> (X >> 8) == 1 232870e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng if ((Cond == ISD::SETEQ || Cond == ISD::SETNE) && 232970e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng N0.getOpcode() == ISD::AND && N0.hasOneUse()) { 233070e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng if (ConstantSDNode *AndRHS = 233170e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng dyn_cast<ConstantSDNode>(N0.getOperand(1))) { 233270e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng const APInt &AndRHSC = AndRHS->getAPIntValue(); 233370e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng if ((-AndRHSC).isPowerOf2() && (AndRHSC & C1) == C1) { 233470e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng unsigned ShiftBits = AndRHSC.countTrailingZeros(); 2335b97cebdfcc4d76835961038b79e605b167bd8cc5Benjamin Kramer EVT ShiftTy = DCI.isBeforeLegalizeOps() ? 233670e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng getPointerTy() : getShiftAmountTy(N0.getValueType()); 233770e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng EVT CmpTy = N0.getValueType(); 233870e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng SDValue Shift = DAG.getNode(ISD::SRL, dl, CmpTy, N0.getOperand(0), 233970e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng DAG.getConstant(ShiftBits, ShiftTy)); 234070e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng SDValue CmpRHS = DAG.getConstant(C1.lshr(ShiftBits), CmpTy); 234170e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng return DAG.getSetCC(dl, VT, Shift, CmpRHS, Cond); 234270e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng } 234370e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng } 2344f5c0539092996771824893309f311378e719e32eEvan Cheng } else if (Cond == ISD::SETULT || Cond == ISD::SETUGE || 2345f5c0539092996771824893309f311378e719e32eEvan Cheng Cond == ISD::SETULE || Cond == ISD::SETUGT) { 2346f5c0539092996771824893309f311378e719e32eEvan Cheng bool AdjOne = (Cond == ISD::SETULE || Cond == ISD::SETUGT); 2347f5c0539092996771824893309f311378e719e32eEvan Cheng // X < 0x100000000 -> (X >> 32) < 1 2348f5c0539092996771824893309f311378e719e32eEvan Cheng // X >= 0x100000000 -> (X >> 32) >= 1 2349f5c0539092996771824893309f311378e719e32eEvan Cheng // X <= 0x0ffffffff -> (X >> 32) < 1 2350f5c0539092996771824893309f311378e719e32eEvan Cheng // X > 0x0ffffffff -> (X >> 32) >= 1 2351f5c0539092996771824893309f311378e719e32eEvan Cheng unsigned ShiftBits; 2352f5c0539092996771824893309f311378e719e32eEvan Cheng APInt NewC = C1; 2353f5c0539092996771824893309f311378e719e32eEvan Cheng ISD::CondCode NewCond = Cond; 2354f5c0539092996771824893309f311378e719e32eEvan Cheng if (AdjOne) { 2355f5c0539092996771824893309f311378e719e32eEvan Cheng ShiftBits = C1.countTrailingOnes(); 2356f5c0539092996771824893309f311378e719e32eEvan Cheng NewC = NewC + 1; 2357f5c0539092996771824893309f311378e719e32eEvan Cheng NewCond = (Cond == ISD::SETULE) ? ISD::SETULT : ISD::SETUGE; 2358f5c0539092996771824893309f311378e719e32eEvan Cheng } else { 2359f5c0539092996771824893309f311378e719e32eEvan Cheng ShiftBits = C1.countTrailingZeros(); 2360f5c0539092996771824893309f311378e719e32eEvan Cheng } 2361f5c0539092996771824893309f311378e719e32eEvan Cheng NewC = NewC.lshr(ShiftBits); 2362f5c0539092996771824893309f311378e719e32eEvan Cheng if (ShiftBits && isLegalICmpImmediate(NewC.getSExtValue())) { 2363b97cebdfcc4d76835961038b79e605b167bd8cc5Benjamin Kramer EVT ShiftTy = DCI.isBeforeLegalizeOps() ? 2364f5c0539092996771824893309f311378e719e32eEvan Cheng getPointerTy() : getShiftAmountTy(N0.getValueType()); 2365f5c0539092996771824893309f311378e719e32eEvan Cheng EVT CmpTy = N0.getValueType(); 2366f5c0539092996771824893309f311378e719e32eEvan Cheng SDValue Shift = DAG.getNode(ISD::SRL, dl, CmpTy, N0, 2367f5c0539092996771824893309f311378e719e32eEvan Cheng DAG.getConstant(ShiftBits, ShiftTy)); 2368f5c0539092996771824893309f311378e719e32eEvan Cheng SDValue CmpRHS = DAG.getConstant(NewC, CmpTy); 2369f5c0539092996771824893309f311378e719e32eEvan Cheng return DAG.getSetCC(dl, VT, Shift, CmpRHS, NewCond); 2370f5c0539092996771824893309f311378e719e32eEvan Cheng } 237170e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng } 237270e10d3fe4c5df189348f64fce56254a5a32b51cEvan Cheng } 2373fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2374fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2375ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isa<ConstantFPSDNode>(N0.getNode())) { 2376fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Constant fold or commute setcc. 2377ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen SDValue O = DAG.FoldSetCC(VT, N0, N1, Cond, dl); 2378ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (O.getNode()) return O; 2379ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif } else if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(N1.getNode())) { 238063079f0757785c5c461bafdd3101ee40aeb717feChris Lattner // If the RHS of an FP comparison is a constant, simplify it away in 238163079f0757785c5c461bafdd3101ee40aeb717feChris Lattner // some cases. 238263079f0757785c5c461bafdd3101ee40aeb717feChris Lattner if (CFP->getValueAPF().isNaN()) { 238363079f0757785c5c461bafdd3101ee40aeb717feChris Lattner // If an operand is known to be a nan, we can fold it. 238463079f0757785c5c461bafdd3101ee40aeb717feChris Lattner switch (ISD::getUnorderedFlavor(Cond)) { 2385c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown flavor!"); 238663079f0757785c5c461bafdd3101ee40aeb717feChris Lattner case 0: // Known false. 238763079f0757785c5c461bafdd3101ee40aeb717feChris Lattner return DAG.getConstant(0, VT); 238863079f0757785c5c461bafdd3101ee40aeb717feChris Lattner case 1: // Known true. 238963079f0757785c5c461bafdd3101ee40aeb717feChris Lattner return DAG.getConstant(1, VT); 23901c3e1e2ed07597111f0b1b1bb93b8080c96c526bChris Lattner case 2: // Undefined. 2391e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen return DAG.getUNDEF(VT); 239263079f0757785c5c461bafdd3101ee40aeb717feChris Lattner } 239363079f0757785c5c461bafdd3101ee40aeb717feChris Lattner } 2394bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 239563079f0757785c5c461bafdd3101ee40aeb717feChris Lattner // Otherwise, we know the RHS is not a NaN. Simplify the node to drop the 239663079f0757785c5c461bafdd3101ee40aeb717feChris Lattner // constant if knowing that the operand is non-nan is enough. We prefer to 239763079f0757785c5c461bafdd3101ee40aeb717feChris Lattner // have SETO(x,x) instead of SETO(x, 0.0) because this avoids having to 239863079f0757785c5c461bafdd3101ee40aeb717feChris Lattner // materialize 0.0. 239963079f0757785c5c461bafdd3101ee40aeb717feChris Lattner if (Cond == ISD::SETO || Cond == ISD::SETUO) 2400ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N0, N0, Cond); 240111eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman 240211eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman // If the condition is not legal, see if we can find an equivalent one 240311eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman // which is legal. 240411eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (!isCondCodeLegal(Cond, N0.getValueType())) { 240511eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman // If the comparison was an awkward floating-point == or != and one of 240611eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman // the comparison operands is infinity or negative infinity, convert the 240711eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman // condition to a less-awkward <= or >=. 240811eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (CFP->getValueAPF().isInfinity()) { 240911eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (CFP->getValueAPF().isNegative()) { 241011eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETOEQ && 241111eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETOLE, N0.getValueType())) 241211eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOLE); 241311eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETUEQ && 241411eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETOLE, N0.getValueType())) 241511eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETULE); 241611eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETUNE && 241711eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETUGT, N0.getValueType())) 241811eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETUGT); 241911eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETONE && 242011eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETUGT, N0.getValueType())) 242111eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOGT); 242211eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman } else { 242311eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETOEQ && 242411eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETOGE, N0.getValueType())) 242511eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOGE); 242611eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETUEQ && 242711eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETOGE, N0.getValueType())) 242811eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETUGE); 242911eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETUNE && 243011eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETULT, N0.getValueType())) 243111eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETULT); 243211eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman if (Cond == ISD::SETONE && 243311eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman isCondCodeLegal(ISD::SETULT, N0.getValueType())) 243411eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOLT); 243511eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman } 243611eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman } 243711eab02b770086c119a18aae0fe214fbe5eed0d0Dan Gohman } 2438fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2439fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2440fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0 == N1) { 2441e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands // The sext(setcc()) => setcc() optimization relies on the appropriate 2442e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands // constant being emitted. 2443e757640df0615510dbc42921cf6271aa76c405eeNadav Rotem uint64_t EqVal = 0; 2444e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands switch (getBooleanContents(N0.getValueType().isVector())) { 2445e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands case UndefinedBooleanContent: 2446e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands case ZeroOrOneBooleanContent: 2447e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands EqVal = ISD::isTrueWhenEqual(Cond); 2448e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands break; 2449e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands case ZeroOrNegativeOneBooleanContent: 2450e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands EqVal = ISD::isTrueWhenEqual(Cond) ? -1 : 0; 2451e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands break; 2452e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands } 2453e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands 2454fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // We can always fold X == X for integer setcc's. 24559dbb018b36d37d9676fe70ac5d928e69ae01b7fbChad Rosier if (N0.getValueType().isInteger()) { 2456e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands return DAG.getConstant(EqVal, VT); 24579dbb018b36d37d9676fe70ac5d928e69ae01b7fbChad Rosier } 2458fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng unsigned UOF = ISD::getUnorderedFlavor(Cond); 2459fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (UOF == 2) // FP operators that are undefined on NaNs. 2460e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands return DAG.getConstant(EqVal, VT); 2461fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (UOF == unsigned(ISD::isTrueWhenEqual(Cond))) 2462e7de3b29f79b147a8f06e6edff0c54149d638139Duncan Sands return DAG.getConstant(EqVal, VT); 2463fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Otherwise, we can't fold it. However, we can simplify it to SETUO/SETO 2464fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // if it is not already. 2465fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng ISD::CondCode NewCond = UOF == 0 ? ISD::SETO : ISD::SETUO; 24668c574be2fec59a3d80e400a9a0409b28f7f34829Micah Villmow if (NewCond != Cond && (DCI.isBeforeLegalizeOps() || 24678c574be2fec59a3d80e400a9a0409b28f7f34829Micah Villmow getCondCodeAction(NewCond, N0.getValueType()) == Legal)) 2468ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N0, N1, NewCond); 2469fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2470fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2471fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if ((Cond == ISD::SETEQ || Cond == ISD::SETNE) && 247283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands N0.getValueType().isInteger()) { 2473fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0.getOpcode() == ISD::ADD || N0.getOpcode() == ISD::SUB || 2474fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng N0.getOpcode() == ISD::XOR) { 2475fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Simplify (X+Y) == (X+Z) --> Y == Z 2476fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0.getOpcode() == N1.getOpcode()) { 2477fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0.getOperand(0) == N1.getOperand(0)) 2478ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N0.getOperand(1), N1.getOperand(1), Cond); 2479fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0.getOperand(1) == N1.getOperand(1)) 2480ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N0.getOperand(0), N1.getOperand(0), Cond); 2481fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (DAG.isCommutativeBinOp(N0.getOpcode())) { 2482fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // If X op Y == Y op X, try other combinations. 2483fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0.getOperand(0) == N1.getOperand(1)) 2484bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, N0.getOperand(1), N1.getOperand(0), 2485ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Cond); 2486fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0.getOperand(1) == N1.getOperand(0)) 2487bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getSetCC(dl, VT, N0.getOperand(0), N1.getOperand(1), 2488ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Cond); 2489fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2490fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2491bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2492740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen // If RHS is a legal immediate value for a compare instruction, we need 2493740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen // to be careful about increasing register pressure needlessly. 2494740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen bool LegalRHSImm = false; 2495740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen 2496fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(N1)) { 2497fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (ConstantSDNode *LHSR = dyn_cast<ConstantSDNode>(N0.getOperand(1))) { 2498fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Turn (X+C1) == C2 --> X == C2-C1 2499ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (N0.getOpcode() == ISD::ADD && N0.getNode()->hasOneUse()) { 2500ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N0.getOperand(0), 2501f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman DAG.getConstant(RHSC->getAPIntValue()- 2502f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman LHSR->getAPIntValue(), 2503fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng N0.getValueType()), Cond); 2504fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2505bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2506fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Turn (X^C1) == C2 into X == C1^C2 iff X&~C1 = 0. 2507fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N0.getOpcode() == ISD::XOR) 2508fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // If we know that all of the inverted bits are zero, don't bother 2509fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // performing the inversion. 25102e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman if (DAG.MaskedValueIsZero(N0.getOperand(0), ~LHSR->getAPIntValue())) 25112e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman return 2512ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen DAG.getSetCC(dl, VT, N0.getOperand(0), 25132e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman DAG.getConstant(LHSR->getAPIntValue() ^ 25142e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman RHSC->getAPIntValue(), 25152e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman N0.getValueType()), 25162e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman Cond); 2517fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2518bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2519fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Turn (C1-X) == C2 --> X == C1-C2 2520fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (ConstantSDNode *SUBC = dyn_cast<ConstantSDNode>(N0.getOperand(0))) { 2521ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (N0.getOpcode() == ISD::SUB && N0.getNode()->hasOneUse()) { 25222e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman return 2523ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen DAG.getSetCC(dl, VT, N0.getOperand(1), 25242e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman DAG.getConstant(SUBC->getAPIntValue() - 25252e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman RHSC->getAPIntValue(), 25262e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman N0.getValueType()), 25272e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman Cond); 2528fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2529bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 2530740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen 2531740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen // Could RHSC fold directly into a compare? 2532740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen if (RHSC->getValueType(0).getSizeInBits() <= 64) 2533740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen LegalRHSImm = isLegalICmpImmediate(RHSC->getSExtValue()); 2534fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2535fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2536fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Simplify (X+Z) == X --> Z == 0 2537740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen // Don't do this if X is an immediate that can fold into a cmp 2538740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen // instruction and X+Z has other uses. It could be an induction variable 2539740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen // chain, and the transform would increase register pressure. 2540740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen if (!LegalRHSImm || N0.getNode()->hasOneUse()) { 2541740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen if (N0.getOperand(0) == N1) 2542740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen return DAG.getSetCC(dl, VT, N0.getOperand(1), 2543740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen DAG.getConstant(0, N0.getValueType()), Cond); 2544740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen if (N0.getOperand(1) == N1) { 2545740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen if (DAG.isCommutativeBinOp(N0.getOpcode())) 2546740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen return DAG.getSetCC(dl, VT, N0.getOperand(0), 2547740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen DAG.getConstant(0, N0.getValueType()), Cond); 2548740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen else if (N0.getNode()->hasOneUse()) { 2549740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen assert(N0.getOpcode() == ISD::SUB && "Unexpected operation!"); 2550740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen // (Z-X) == X --> Z == X<<1 2551740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen SDValue SH = DAG.getNode(ISD::SHL, dl, N1.getValueType(), N1, 255295771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(1, getShiftAmountTy(N1.getValueType()))); 2553740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen if (!DCI.isCalledByLegalizer()) 2554740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen DCI.AddToWorklist(SH.getNode()); 2555740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen return DAG.getSetCC(dl, VT, N0.getOperand(0), SH, Cond); 2556740cd657f3d9d4e88614831c70a649f9257164daJakob Stoklund Olesen } 2557fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2558fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2559fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2560fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2561fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N1.getOpcode() == ISD::ADD || N1.getOpcode() == ISD::SUB || 2562fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng N1.getOpcode() == ISD::XOR) { 2563fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Simplify X == (X+Z) --> Z == 0 2564fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (N1.getOperand(0) == N0) { 2565ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N1.getOperand(1), 2566fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng DAG.getConstant(0, N1.getValueType()), Cond); 2567fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } else if (N1.getOperand(1) == N0) { 2568fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (DAG.isCommutativeBinOp(N1.getOpcode())) { 2569ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N1.getOperand(0), 2570fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng DAG.getConstant(0, N1.getValueType()), Cond); 2571ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif } else if (N1.getNode()->hasOneUse()) { 2572fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng assert(N1.getOpcode() == ISD::SUB && "Unexpected operation!"); 2573fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // X == (Z-X) --> X<<1 == Z 2574bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue SH = DAG.getNode(ISD::SHL, dl, N1.getValueType(), N0, 257595771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(1, getShiftAmountTy(N0.getValueType()))); 2576fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (!DCI.isCalledByLegalizer()) 2577ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif DCI.AddToWorklist(SH.getNode()); 2578ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, SH, N1.getOperand(0), Cond); 2579fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2580fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2581fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2582e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman 25832c65c3dfe6589a630d1bdde085aec1b9cdc43ea8Dan Gohman // Simplify x&y == y to x&y != 0 if y has exactly one bit set. 258485b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesen // Note that where y is variable and is known to have at most 258585b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesen // one bit set (for example, if it is z&1) we cannot do this; 258685b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesen // the expressions are not equivalent when y==0. 2587e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman if (N0.getOpcode() == ISD::AND) 2588e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman if (N0.getOperand(0) == N1 || N0.getOperand(1) == N1) { 258985b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesen if (ValueHasExactlyOneBitSet(N1, DAG)) { 2590e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman Cond = ISD::getSetCCInverse(Cond, /*isInteger=*/true); 2591e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman SDValue Zero = DAG.getConstant(0, N1.getValueType()); 2592ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N0, Zero, Cond); 2593e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman } 2594e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman } 2595e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman if (N1.getOpcode() == ISD::AND) 2596e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman if (N1.getOperand(0) == N0 || N1.getOperand(1) == N0) { 259785b0edec4672f6ac6c15f757b119d04232a61861Dale Johannesen if (ValueHasExactlyOneBitSet(N0, DAG)) { 2598e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman Cond = ISD::getSetCCInverse(Cond, /*isInteger=*/true); 2599e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman SDValue Zero = DAG.getConstant(0, N0.getValueType()); 2600ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getSetCC(dl, VT, N1, Zero, Cond); 2601e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman } 2602e5af2d3a224d4b38760a26d237cde040cb6e14ebDan Gohman } 2603fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2604fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2605fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Fold away ALL boolean setcc's. 2606475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Temp; 2607825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N0.getValueType() == MVT::i1 && foldBooleans) { 2608fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng switch (Cond) { 2609c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown integer setcc!"); 26104c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETEQ: // X == Y -> ~(X^Y) 2611825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Temp = DAG.getNode(ISD::XOR, dl, MVT::i1, N0, N1); 2612825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson N0 = DAG.getNOT(dl, Temp, MVT::i1); 2613fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (!DCI.isCalledByLegalizer()) 2614ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif DCI.AddToWorklist(Temp.getNode()); 2615fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng break; 2616fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng case ISD::SETNE: // X != Y --> (X^Y) 2617825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson N0 = DAG.getNode(ISD::XOR, dl, MVT::i1, N0, N1); 2618fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng break; 26194c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETGT: // X >s Y --> X == 0 & Y == 1 --> ~X & Y 26204c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETULT: // X <u Y --> X == 0 & Y == 1 --> ~X & Y 2621825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Temp = DAG.getNOT(dl, N0, MVT::i1); 2622825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson N0 = DAG.getNode(ISD::AND, dl, MVT::i1, N1, Temp); 2623fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (!DCI.isCalledByLegalizer()) 2624ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif DCI.AddToWorklist(Temp.getNode()); 2625fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng break; 26264c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETLT: // X <s Y --> X == 1 & Y == 0 --> ~Y & X 26274c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETUGT: // X >u Y --> X == 1 & Y == 0 --> ~Y & X 2628825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Temp = DAG.getNOT(dl, N1, MVT::i1); 2629825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson N0 = DAG.getNode(ISD::AND, dl, MVT::i1, N0, Temp); 2630fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (!DCI.isCalledByLegalizer()) 2631ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif DCI.AddToWorklist(Temp.getNode()); 2632fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng break; 26334c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETULE: // X <=u Y --> X == 0 | Y == 1 --> ~X | Y 26344c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETGE: // X >=s Y --> X == 0 | Y == 1 --> ~X | Y 2635825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Temp = DAG.getNOT(dl, N0, MVT::i1); 2636825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson N0 = DAG.getNode(ISD::OR, dl, MVT::i1, N1, Temp); 2637fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (!DCI.isCalledByLegalizer()) 2638ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif DCI.AddToWorklist(Temp.getNode()); 2639fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng break; 26404c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETUGE: // X >=u Y --> X == 1 | Y == 0 --> ~Y | X 26414c2454623841f05c6c665659b34c214950d12d7eBob Wilson case ISD::SETLE: // X <=s Y --> X == 1 | Y == 0 --> ~Y | X 2642825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Temp = DAG.getNOT(dl, N1, MVT::i1); 2643825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson N0 = DAG.getNode(ISD::OR, dl, MVT::i1, N0, Temp); 2644fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng break; 2645fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2646825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT != MVT::i1) { 2647fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng if (!DCI.isCalledByLegalizer()) 2648ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif DCI.AddToWorklist(N0.getNode()); 2649fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // FIXME: If running after legalize, we probably can't do this. 2650ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen N0 = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, N0); 2651fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2652fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng return N0; 2653fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng } 2654fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2655fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng // Could not fold it. 2656475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(); 2657fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng} 2658fa1eb27b76ab1e0f78574bf52a432c84a4c1a520Evan Cheng 2659ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng/// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the 2660ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng/// node is a GlobalAddress + offset. 26610a9481f44fe4fc76e59109992940a76b2a3f9b3bChris Lattnerbool TargetLowering::isGAPlusOffset(SDNode *N, const GlobalValue *&GA, 2662ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng int64_t &Offset) const { 2663ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng if (isa<GlobalAddressSDNode>(N)) { 26649ea3f56d07875ecb4ae2cd5bc14a9563b9742553Dan Gohman GlobalAddressSDNode *GASD = cast<GlobalAddressSDNode>(N); 26659ea3f56d07875ecb4ae2cd5bc14a9563b9742553Dan Gohman GA = GASD->getGlobal(); 26669ea3f56d07875ecb4ae2cd5bc14a9563b9742553Dan Gohman Offset += GASD->getOffset(); 2667ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng return true; 2668ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng } 2669ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng 2670ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng if (N->getOpcode() == ISD::ADD) { 2671475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue N1 = N->getOperand(0); 2672475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue N2 = N->getOperand(1); 2673ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isGAPlusOffset(N1.getNode(), GA, Offset)) { 2674ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng ConstantSDNode *V = dyn_cast<ConstantSDNode>(N2); 2675ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng if (V) { 26767810bfed5570c192e0714a8fd0e5130a0c38dd2eDan Gohman Offset += V->getSExtValue(); 2677ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng return true; 2678ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng } 2679ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif } else if (isGAPlusOffset(N2.getNode(), GA, Offset)) { 2680ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng ConstantSDNode *V = dyn_cast<ConstantSDNode>(N1); 2681ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng if (V) { 26827810bfed5570c192e0714a8fd0e5130a0c38dd2eDan Gohman Offset += V->getSExtValue(); 2683ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng return true; 2684ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng } 2685ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng } 2686ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng } 268795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson 2688ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng return false; 2689ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng} 2690ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng 2691ad4196b44ae714a6b95e238d9d96303df74b0429Evan Cheng 2692475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue TargetLowering:: 269300ffed0468ad406062b7c08c2ff46d79d2d1be4dChris LattnerPerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const { 269400ffed0468ad406062b7c08c2ff46d79d2d1be4dChris Lattner // Default implementation: no optimization. 2695475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(); 269600ffed0468ad406062b7c08c2ff46d79d2d1be4dChris Lattner} 269700ffed0468ad406062b7c08c2ff46d79d2d1be4dChris Lattner 2698eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner//===----------------------------------------------------------------------===// 2699eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner// Inline Assembler Implementation Methods 2700eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner//===----------------------------------------------------------------------===// 2701eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner 27024376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner 2703eb8146b5ee4b9b66d6294f62a5ed556e332018abChris LattnerTargetLowering::ConstraintType 27044234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris LattnerTargetLowering::getConstraintType(const std::string &Constraint) const { 27054234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner if (Constraint.size() == 1) { 27064234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner switch (Constraint[0]) { 27074234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner default: break; 27084234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'r': return C_RegisterClass; 27094234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'm': // memory 27104234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'o': // offsetable 27114234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'V': // not offsetable 27124234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner return C_Memory; 27134234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'i': // Simple Integer or Relocatable Constant 27144234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'n': // Simple Integer 271567aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson case 'E': // Floating Point Constant 271667aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson case 'F': // Floating Point Constant 27174234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 's': // Relocatable Constant 271867aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson case 'p': // Address. 2719c13dd1cf4c0d83ac3ed2a6b0c36fab72e9d6c6e5Chris Lattner case 'X': // Allow ANY value. 27204234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'I': // Target registers. 27214234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'J': 27224234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'K': 27234234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'L': 27244234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'M': 27254234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'N': 27264234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'O': 27274234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner case 'P': 272867aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson case '<': 272967aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson case '>': 27304234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner return C_Other; 27314234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner } 2732eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner } 2733bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2734bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (Constraint.size() > 1 && Constraint[0] == '{' && 2735065421f99fc155c3910a77c3a47de99f3f6af4d0Chris Lattner Constraint[Constraint.size()-1] == '}') 2736065421f99fc155c3910a77c3a47de99f3f6af4d0Chris Lattner return C_Register; 27374234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner return C_Unknown; 2738eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner} 2739eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner 2740ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen/// LowerXConstraint - try to replace an X constraint, which matches anything, 2741ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen/// with another that has more specific requirements based on the type of the 2742ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen/// corresponding operand. 2743e50ed30282bb5b4a9ed952580523f2dda16215acOwen Andersonconst char *TargetLowering::LowerXConstraint(EVT ConstraintVT) const{ 274483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ConstraintVT.isInteger()) 27455e764233f398b6929b67701672a5e78fec20ce2eChris Lattner return "r"; 274683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ConstraintVT.isFloatingPoint()) 27475e764233f398b6929b67701672a5e78fec20ce2eChris Lattner return "f"; // works for many targets 27485e764233f398b6929b67701672a5e78fec20ce2eChris Lattner return 0; 2749ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen} 2750ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen 275148884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops 275248884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner/// vector. If it is invalid, don't add anything to Ops. 2753475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid TargetLowering::LowerAsmOperandForConstraint(SDValue Op, 2754100c83341676d8aae8fc34b5452563ed08b14f3eEric Christopher std::string &Constraint, 2755475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::vector<SDValue> &Ops, 27565e764233f398b6929b67701672a5e78fec20ce2eChris Lattner SelectionDAG &DAG) const { 2757362fee90b9a1d64ac091755466caf6a94ade22ebEric Christopher 2758100c83341676d8aae8fc34b5452563ed08b14f3eEric Christopher if (Constraint.length() > 1) return; 2759362fee90b9a1d64ac091755466caf6a94ade22ebEric Christopher 2760100c83341676d8aae8fc34b5452563ed08b14f3eEric Christopher char ConstraintLetter = Constraint[0]; 2761eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner switch (ConstraintLetter) { 27629ff6ee85fe281c5686e0885eaa0c37ad5378ed52Chris Lattner default: break; 2763eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen case 'X': // Allows any operand; labels (basic block) use this. 2764eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen if (Op.getOpcode() == ISD::BasicBlock) { 2765eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Ops.push_back(Op); 2766eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen return; 2767eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } 2768eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen // fall through 2769eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner case 'i': // Simple Integer or Relocatable Constant 2770eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner case 'n': // Simple Integer 2771eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen case 's': { // Relocatable Constant 277275c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner // These operands are interested in values of the form (GV+C), where C may 277375c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner // be folded in as an offset of GV, or it may be explicitly added. Also, it 277475c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner // is possible and fine if either GV or C are missing. 277575c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op); 277675c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op); 2777bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 277875c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner // If we have "(add GV, C)", pull out GV/C 277975c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner if (Op.getOpcode() == ISD::ADD) { 278075c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner C = dyn_cast<ConstantSDNode>(Op.getOperand(1)); 278175c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner GA = dyn_cast<GlobalAddressSDNode>(Op.getOperand(0)); 278275c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner if (C == 0 || GA == 0) { 278375c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner C = dyn_cast<ConstantSDNode>(Op.getOperand(0)); 278475c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner GA = dyn_cast<GlobalAddressSDNode>(Op.getOperand(1)); 278575c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner } 278675c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner if (C == 0 || GA == 0) 278775c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner C = 0, GA = 0; 278875c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner } 2789bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 279075c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner // If we find a valid operand, map to the TargetXXX version so that the 279175c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner // value itself doesn't get selected. 279275c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner if (GA) { // Either &GV or &GV+C 279375c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner if (ConstraintLetter != 'n') { 279475c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner int64_t Offs = GA->getOffset(); 2795f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman if (C) Offs += C->getZExtValue(); 2796bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Ops.push_back(DAG.getTargetGlobalAddress(GA->getGlobal(), 279707538ad975994123317fe5b32daed4bf28683a1dDevang Patel C ? C->getDebugLoc() : DebugLoc(), 279848884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner Op.getValueType(), Offs)); 279948884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner return; 280075c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner } 280175c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner } 280275c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner if (C) { // just C, no GV. 28039ff6ee85fe281c5686e0885eaa0c37ad5378ed52Chris Lattner // Simple constants are not allowed for 's'. 280448884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner if (ConstraintLetter != 's') { 280578e3e521cd90e5f6382c14b6e4d809fb59610ed6Dale Johannesen // gcc prints these as sign extended. Sign extend value to 64 bits 280678e3e521cd90e5f6382c14b6e4d809fb59610ed6Dale Johannesen // now; without this it would get ZExt'd later in 280778e3e521cd90e5f6382c14b6e4d809fb59610ed6Dale Johannesen // ScheduleDAGSDNodes::EmitNode, which is very generic. 280878e3e521cd90e5f6382c14b6e4d809fb59610ed6Dale Johannesen Ops.push_back(DAG.getTargetConstant(C->getAPIntValue().getSExtValue(), 2809825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::i64)); 281048884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner return; 281148884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner } 28129ff6ee85fe281c5686e0885eaa0c37ad5378ed52Chris Lattner } 28139ff6ee85fe281c5686e0885eaa0c37ad5378ed52Chris Lattner break; 2814eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner } 281575c7d2bd551acd1ad4f0f58b763ec8840f1d9c34Chris Lattner } 2816eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner} 2817eb8146b5ee4b9b66d6294f62a5ed556e332018abChris Lattner 28181efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattnerstd::pair<unsigned, const TargetRegisterClass*> TargetLowering:: 28194217ca8dc175f7268a4335c8406dedd901e8e631Chris LattnergetRegForInlineAsmConstraint(const std::string &Constraint, 2820e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT) const { 28211efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner if (Constraint[0] != '{') 28227d9663c70b3300070298d716dba6e6f6ce2d1e3eDouglas Gregor return std::make_pair(0u, static_cast<TargetRegisterClass*>(0)); 2823a55079a5ccdf0cdb4d482fb47a3fb21825f56713Chris Lattner assert(*(Constraint.end()-1) == '}' && "Not a brace enclosed constraint?"); 2824a55079a5ccdf0cdb4d482fb47a3fb21825f56713Chris Lattner 2825a55079a5ccdf0cdb4d482fb47a3fb21825f56713Chris Lattner // Remove the braces from around the name. 282605872ea804cdc9534960b30d28a391928c61481aBenjamin Kramer StringRef RegName(Constraint.data()+1, Constraint.size()-2); 28271efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 28281efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // Figure out which register class contains this reg. 28296f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *RI = TM.getRegisterInfo(); 28306f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman for (TargetRegisterInfo::regclass_iterator RCI = RI->regclass_begin(), 28311efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner E = RI->regclass_end(); RCI != E; ++RCI) { 28321efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner const TargetRegisterClass *RC = *RCI; 2833bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2834bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // If none of the value types for this register class are valid, we 2835b3befd41b4b5aa882bed9796bbb097df29b505acChris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 283622e8a366adf5a4c78148928ff64e7e00c1088492Jakob Stoklund Olesen if (!isLegalRC(RC)) 283722e8a366adf5a4c78148928ff64e7e00c1088492Jakob Stoklund Olesen continue; 2838bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2839bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck for (TargetRegisterClass::iterator I = RC->begin(), E = RC->end(); 28401efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner I != E; ++I) { 284105872ea804cdc9534960b30d28a391928c61481aBenjamin Kramer if (RegName.equals_lower(RI->getName(*I))) 28421efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner return std::make_pair(*I, RC); 28431efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 28444ccb070f158b0f331c68de800c6bab8c31c2ecb6Chris Lattner } 2845bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 28467d9663c70b3300070298d716dba6e6f6ce2d1e3eDouglas Gregor return std::make_pair(0u, static_cast<const TargetRegisterClass*>(0)); 28474ccb070f158b0f331c68de800c6bab8c31c2ecb6Chris Lattner} 284830b37b5f29991874648d839d018aa2921b39355fEvan Cheng 284930b37b5f29991874648d839d018aa2921b39355fEvan Cheng//===----------------------------------------------------------------------===// 28504376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner// Constraint Selection. 28514376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner 28526bdcda3d3e30003fb6cef1d4e2fd3a5d5b40d3fcChris Lattner/// isMatchingInputConstraint - Return true of this is an input operand that is 28536bdcda3d3e30003fb6cef1d4e2fd3a5d5b40d3fcChris Lattner/// a matching constraint like "4". 28546bdcda3d3e30003fb6cef1d4e2fd3a5d5b40d3fcChris Lattnerbool TargetLowering::AsmOperandInfo::isMatchingInputConstraint() const { 285558f15c482a7129c78ca809792b46befa20ea337dChris Lattner assert(!ConstraintCode.empty() && "No known constraint!"); 285658f15c482a7129c78ca809792b46befa20ea337dChris Lattner return isdigit(ConstraintCode[0]); 285758f15c482a7129c78ca809792b46befa20ea337dChris Lattner} 285858f15c482a7129c78ca809792b46befa20ea337dChris Lattner 285958f15c482a7129c78ca809792b46befa20ea337dChris Lattner/// getMatchedOperand - If this is an input matching constraint, this method 286058f15c482a7129c78ca809792b46befa20ea337dChris Lattner/// returns the output operand it matches. 286158f15c482a7129c78ca809792b46befa20ea337dChris Lattnerunsigned TargetLowering::AsmOperandInfo::getMatchedOperand() const { 286258f15c482a7129c78ca809792b46befa20ea337dChris Lattner assert(!ConstraintCode.empty() && "No known constraint!"); 286358f15c482a7129c78ca809792b46befa20ea337dChris Lattner return atoi(ConstraintCode.c_str()); 286458f15c482a7129c78ca809792b46befa20ea337dChris Lattner} 286558f15c482a7129c78ca809792b46befa20ea337dChris Lattner 2866bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2867eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// ParseConstraints - Split up the constraint string from the inline 2868eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// assembly value into the specific constraints and their prefixes, 2869eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// and also tie in the associated operand values. 2870eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// If this returns an empty vector, and if the constraint string itself 2871eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// isn't empty, there was an error parsing. 287244ab89eb376af838d1123293a79975aede501464John ThompsonTargetLowering::AsmOperandInfoVector TargetLowering::ParseConstraints( 2873eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson ImmutableCallSite CS) const { 2874eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson /// ConstraintOperands - Information about all of the constraints. 287544ab89eb376af838d1123293a79975aede501464John Thompson AsmOperandInfoVector ConstraintOperands; 2876eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson const InlineAsm *IA = cast<InlineAsm>(CS.getCalledValue()); 287767aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson unsigned maCount = 0; // Largest number of multiple alternative constraints. 2878eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 2879eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Do a prepass over the constraints, canonicalizing them, and building up the 2880eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // ConstraintOperands list. 288144ab89eb376af838d1123293a79975aede501464John Thompson InlineAsm::ConstraintInfoVector 2882eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson ConstraintInfos = IA->ParseConstraints(); 2883bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2884eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson unsigned ArgNo = 0; // ArgNo - The argument of the CallInst. 2885eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson unsigned ResNo = 0; // ResNo - The result number of the next output. 2886eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 2887eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson for (unsigned i = 0, e = ConstraintInfos.size(); i != e; ++i) { 2888eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson ConstraintOperands.push_back(AsmOperandInfo(ConstraintInfos[i])); 2889eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo &OpInfo = ConstraintOperands.back(); 2890eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 289167aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson // Update multiple alternative constraint count. 289267aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson if (OpInfo.multipleAlternatives.size() > maCount) 289367aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson maCount = OpInfo.multipleAlternatives.size(); 289467aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson 289544ab89eb376af838d1123293a79975aede501464John Thompson OpInfo.ConstraintVT = MVT::Other; 2896eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 2897eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Compute the value type for each operand. 2898eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson switch (OpInfo.Type) { 2899eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case InlineAsm::isOutput: 2900eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Indirect outputs just consume an argument. 2901eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (OpInfo.isIndirect) { 2902eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson OpInfo.CallOperandVal = const_cast<Value *>(CS.getArgument(ArgNo++)); 2903eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 2904eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 2905eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 2906eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // The return value of the call is this value. As such, there is no 2907eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // corresponding argument. 2908eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson assert(!CS.getType()->isVoidTy() && 2909eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson "Bad inline asm!"); 2910db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(CS.getType())) { 291144ab89eb376af838d1123293a79975aede501464John Thompson OpInfo.ConstraintVT = getValueType(STy->getElementType(ResNo)); 2912eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } else { 2913eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson assert(ResNo == 0 && "Asm only has one result!"); 291444ab89eb376af838d1123293a79975aede501464John Thompson OpInfo.ConstraintVT = getValueType(CS.getType()); 2915eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 2916eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson ++ResNo; 2917eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 2918eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case InlineAsm::isInput: 2919eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson OpInfo.CallOperandVal = const_cast<Value *>(CS.getArgument(ArgNo++)); 2920eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 2921eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case InlineAsm::isClobber: 2922eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Nothing to do. 2923eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 2924eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 2925bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 292644ab89eb376af838d1123293a79975aede501464John Thompson if (OpInfo.CallOperandVal) { 2927db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner llvm::Type *OpTy = OpInfo.CallOperandVal->getType(); 292844ab89eb376af838d1123293a79975aede501464John Thompson if (OpInfo.isIndirect) { 2929db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner llvm::PointerType *PtrTy = dyn_cast<PointerType>(OpTy); 293044ab89eb376af838d1123293a79975aede501464John Thompson if (!PtrTy) 293144ab89eb376af838d1123293a79975aede501464John Thompson report_fatal_error("Indirect operand for inline asm not a pointer!"); 293244ab89eb376af838d1123293a79975aede501464John Thompson OpTy = PtrTy->getElementType(); 293344ab89eb376af838d1123293a79975aede501464John Thompson } 2934362fee90b9a1d64ac091755466caf6a94ade22ebEric Christopher 2935cef81b7e519764c6a008a689bc4c6dfc9119f8e9Eric Christopher // Look for vector wrapped in a struct. e.g. { <16 x i8> }. 2936db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(OpTy)) 2937cef81b7e519764c6a008a689bc4c6dfc9119f8e9Eric Christopher if (STy->getNumElements() == 1) 2938cef81b7e519764c6a008a689bc4c6dfc9119f8e9Eric Christopher OpTy = STy->getElementType(0); 2939cef81b7e519764c6a008a689bc4c6dfc9119f8e9Eric Christopher 294044ab89eb376af838d1123293a79975aede501464John Thompson // If OpTy is not a single value, it may be a struct/union that we 294144ab89eb376af838d1123293a79975aede501464John Thompson // can tile with integers. 294244ab89eb376af838d1123293a79975aede501464John Thompson if (!OpTy->isSingleValueType() && OpTy->isSized()) { 294344ab89eb376af838d1123293a79975aede501464John Thompson unsigned BitSize = TD->getTypeSizeInBits(OpTy); 294444ab89eb376af838d1123293a79975aede501464John Thompson switch (BitSize) { 294544ab89eb376af838d1123293a79975aede501464John Thompson default: break; 294644ab89eb376af838d1123293a79975aede501464John Thompson case 1: 294744ab89eb376af838d1123293a79975aede501464John Thompson case 8: 294844ab89eb376af838d1123293a79975aede501464John Thompson case 16: 294944ab89eb376af838d1123293a79975aede501464John Thompson case 32: 295044ab89eb376af838d1123293a79975aede501464John Thompson case 64: 295144ab89eb376af838d1123293a79975aede501464John Thompson case 128: 295271365d3774a6c02f3f198fbf08a56e4b6346bbccDale Johannesen OpInfo.ConstraintVT = 295371365d3774a6c02f3f198fbf08a56e4b6346bbccDale Johannesen EVT::getEVT(IntegerType::get(OpTy->getContext(), BitSize), true); 295444ab89eb376af838d1123293a79975aede501464John Thompson break; 295544ab89eb376af838d1123293a79975aede501464John Thompson } 295644ab89eb376af838d1123293a79975aede501464John Thompson } else if (dyn_cast<PointerType>(OpTy)) { 295744ab89eb376af838d1123293a79975aede501464John Thompson OpInfo.ConstraintVT = MVT::getIntegerVT(8*TD->getPointerSize()); 295844ab89eb376af838d1123293a79975aede501464John Thompson } else { 295944ab89eb376af838d1123293a79975aede501464John Thompson OpInfo.ConstraintVT = EVT::getEVT(OpTy, true); 296044ab89eb376af838d1123293a79975aede501464John Thompson } 296144ab89eb376af838d1123293a79975aede501464John Thompson } 2962eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 2963eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 2964eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // If we have multiple alternative constraints, select the best alternative. 2965eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (ConstraintInfos.size()) { 2966eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (maCount) { 2967eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson unsigned bestMAIndex = 0; 2968eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson int bestWeight = -1; 2969eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // weight: -1 = invalid match, and 0 = so-so match to 5 = good match. 2970eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson int weight = -1; 2971eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson unsigned maIndex; 2972eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Compute the sums of the weights for each alternative, keeping track 2973eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // of the best (highest weight) one so far. 2974eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson for (maIndex = 0; maIndex < maCount; ++maIndex) { 2975eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson int weightSum = 0; 2976eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson for (unsigned cIndex = 0, eIndex = ConstraintOperands.size(); 2977eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson cIndex != eIndex; ++cIndex) { 2978eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo& OpInfo = ConstraintOperands[cIndex]; 2979eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (OpInfo.Type == InlineAsm::isClobber) 2980eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson continue; 2981eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 298244ab89eb376af838d1123293a79975aede501464John Thompson // If this is an output operand with a matching input operand, 298344ab89eb376af838d1123293a79975aede501464John Thompson // look up the matching input. If their types mismatch, e.g. one 298444ab89eb376af838d1123293a79975aede501464John Thompson // is an integer, the other is floating point, or their sizes are 298544ab89eb376af838d1123293a79975aede501464John Thompson // different, flag it as an maCantMatch. 2986eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (OpInfo.hasMatchingInput()) { 2987eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo &Input = ConstraintOperands[OpInfo.MatchingInput]; 2988eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (OpInfo.ConstraintVT != Input.ConstraintVT) { 2989eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if ((OpInfo.ConstraintVT.isInteger() != 2990eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson Input.ConstraintVT.isInteger()) || 2991eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson (OpInfo.ConstraintVT.getSizeInBits() != 2992eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson Input.ConstraintVT.getSizeInBits())) { 2993eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson weightSum = -1; // Can't match. 2994eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 2995eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 2996eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 2997eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 2998eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson weight = getMultipleConstraintMatchWeight(OpInfo, maIndex); 2999eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (weight == -1) { 3000eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson weightSum = -1; 3001eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 3002eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3003eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson weightSum += weight; 3004eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3005eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Update best. 3006eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (weightSum > bestWeight) { 3007eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson bestWeight = weightSum; 3008eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson bestMAIndex = maIndex; 3009eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3010eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3011eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 3012eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Now select chosen alternative in each constraint. 3013eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson for (unsigned cIndex = 0, eIndex = ConstraintOperands.size(); 3014eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson cIndex != eIndex; ++cIndex) { 3015eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo& cInfo = ConstraintOperands[cIndex]; 3016eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (cInfo.Type == InlineAsm::isClobber) 3017eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson continue; 3018eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson cInfo.selectAlternative(bestMAIndex); 3019eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3020eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3021eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3022eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 3023eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Check and hook up tied operands, choose constraint code to use. 3024eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson for (unsigned cIndex = 0, eIndex = ConstraintOperands.size(); 3025eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson cIndex != eIndex; ++cIndex) { 3026eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo& OpInfo = ConstraintOperands[cIndex]; 3027bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 3028eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // If this is an output operand with a matching input operand, look up the 3029eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // matching input. If their types mismatch, e.g. one is an integer, the 3030eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // other is floating point, or their sizes are different, flag it as an 3031eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // error. 3032eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (OpInfo.hasMatchingInput()) { 3033eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo &Input = ConstraintOperands[OpInfo.MatchingInput]; 303444ab89eb376af838d1123293a79975aede501464John Thompson 3035eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (OpInfo.ConstraintVT != Input.ConstraintVT) { 303696cb1128528a512f1ef9c28ae5e1b78a98dcc505Bill Wendling std::pair<unsigned, const TargetRegisterClass*> MatchRC = 303796cb1128528a512f1ef9c28ae5e1b78a98dcc505Bill Wendling getRegForInlineAsmConstraint(OpInfo.ConstraintCode, 303896cb1128528a512f1ef9c28ae5e1b78a98dcc505Bill Wendling OpInfo.ConstraintVT); 303996cb1128528a512f1ef9c28ae5e1b78a98dcc505Bill Wendling std::pair<unsigned, const TargetRegisterClass*> InputRC = 304096cb1128528a512f1ef9c28ae5e1b78a98dcc505Bill Wendling getRegForInlineAsmConstraint(Input.ConstraintCode, 304196cb1128528a512f1ef9c28ae5e1b78a98dcc505Bill Wendling Input.ConstraintVT); 3042eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if ((OpInfo.ConstraintVT.isInteger() != 3043eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson Input.ConstraintVT.isInteger()) || 30445427edeb68d653ced860ed14f83848ebbb01b64bEric Christopher (MatchRC.second != InputRC.second)) { 3045eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson report_fatal_error("Unsupported asm: input constraint" 3046eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson " with a matching output constraint of" 3047eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson " incompatible type!"); 3048eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3049eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 305044ab89eb376af838d1123293a79975aede501464John Thompson 3051eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3052eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3053eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 3054eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson return ConstraintOperands; 3055eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson} 3056eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 305758f15c482a7129c78ca809792b46befa20ea337dChris Lattner 30584376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// getConstraintGenerality - Return an integer indicating how general CT 30594376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// is. 30604376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattnerstatic unsigned getConstraintGenerality(TargetLowering::ConstraintType CT) { 30614376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner switch (CT) { 30624376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner case TargetLowering::C_Other: 30634376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner case TargetLowering::C_Unknown: 30644376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner return 0; 30654376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner case TargetLowering::C_Register: 30664376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner return 1; 30674376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner case TargetLowering::C_RegisterClass: 30684376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner return 2; 30694376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner case TargetLowering::C_Memory: 30704376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner return 3; 30714376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner } 3072732f05c41f177a0bc4d47e93a5d02120f146cb4cChandler Carruth llvm_unreachable("Invalid constraint type"); 30734376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner} 30744376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner 307544ab89eb376af838d1123293a79975aede501464John Thompson/// Examine constraint type and operand type and determine a weight value. 3076eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// This object must already have been set up with the operand type 3077eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// and the current alternative constraint selected. 307844ab89eb376af838d1123293a79975aede501464John ThompsonTargetLowering::ConstraintWeight 307944ab89eb376af838d1123293a79975aede501464John Thompson TargetLowering::getMultipleConstraintMatchWeight( 3080eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo &info, int maIndex) const { 308144ab89eb376af838d1123293a79975aede501464John Thompson InlineAsm::ConstraintCodeVector *rCodes; 308267aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson if (maIndex >= (int)info.multipleAlternatives.size()) 308367aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson rCodes = &info.Codes; 308467aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson else 308567aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson rCodes = &info.multipleAlternatives[maIndex].Codes; 308644ab89eb376af838d1123293a79975aede501464John Thompson ConstraintWeight BestWeight = CW_Invalid; 3087eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 3088eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Loop over the options, keeping track of the most general one. 308967aff164c039765e3ec19e5a31659250c8427dfbJohn Thompson for (unsigned i = 0, e = rCodes->size(); i != e; ++i) { 309044ab89eb376af838d1123293a79975aede501464John Thompson ConstraintWeight weight = 309144ab89eb376af838d1123293a79975aede501464John Thompson getSingleConstraintMatchWeight(info, (*rCodes)[i].c_str()); 3092eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (weight > BestWeight) 3093eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson BestWeight = weight; 3094eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3095eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 3096eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson return BestWeight; 3097eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson} 3098eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 309944ab89eb376af838d1123293a79975aede501464John Thompson/// Examine constraint type and operand type and determine a weight value. 3100eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// This object must already have been set up with the operand type 3101eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson/// and the current alternative constraint selected. 310244ab89eb376af838d1123293a79975aede501464John ThompsonTargetLowering::ConstraintWeight 310344ab89eb376af838d1123293a79975aede501464John Thompson TargetLowering::getSingleConstraintMatchWeight( 3104eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson AsmOperandInfo &info, const char *constraint) const { 310544ab89eb376af838d1123293a79975aede501464John Thompson ConstraintWeight weight = CW_Invalid; 3106eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson Value *CallOperandVal = info.CallOperandVal; 3107eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // If we don't have a value, we can't do a match, 3108eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // but allow it at the lowest weight. 3109eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson if (CallOperandVal == NULL) 311044ab89eb376af838d1123293a79975aede501464John Thompson return CW_Default; 3111eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson // Look at the constraint type. 3112eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson switch (*constraint) { 3113eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case 'i': // immediate integer. 3114eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case 'n': // immediate integer with a known value. 311544ab89eb376af838d1123293a79975aede501464John Thompson if (isa<ConstantInt>(CallOperandVal)) 311644ab89eb376af838d1123293a79975aede501464John Thompson weight = CW_Constant; 3117eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 3118eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case 's': // non-explicit intregal immediate. 311944ab89eb376af838d1123293a79975aede501464John Thompson if (isa<GlobalValue>(CallOperandVal)) 312044ab89eb376af838d1123293a79975aede501464John Thompson weight = CW_Constant; 312144ab89eb376af838d1123293a79975aede501464John Thompson break; 312244ab89eb376af838d1123293a79975aede501464John Thompson case 'E': // immediate float if host format. 312344ab89eb376af838d1123293a79975aede501464John Thompson case 'F': // immediate float. 312444ab89eb376af838d1123293a79975aede501464John Thompson if (isa<ConstantFP>(CallOperandVal)) 312544ab89eb376af838d1123293a79975aede501464John Thompson weight = CW_Constant; 3126eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 312744ab89eb376af838d1123293a79975aede501464John Thompson case '<': // memory operand with autodecrement. 312844ab89eb376af838d1123293a79975aede501464John Thompson case '>': // memory operand with autoincrement. 3129eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case 'm': // memory operand. 3130eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case 'o': // offsettable memory operand 3131eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case 'V': // non-offsettable memory operand 313244ab89eb376af838d1123293a79975aede501464John Thompson weight = CW_Memory; 3133eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 313444ab89eb376af838d1123293a79975aede501464John Thompson case 'r': // general register. 3135eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson case 'g': // general register, memory operand or immediate integer. 313644ab89eb376af838d1123293a79975aede501464John Thompson // note: Clang converts "g" to "imr". 313744ab89eb376af838d1123293a79975aede501464John Thompson if (CallOperandVal->getType()->isIntegerTy()) 313844ab89eb376af838d1123293a79975aede501464John Thompson weight = CW_Register; 3139eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 314044ab89eb376af838d1123293a79975aede501464John Thompson case 'X': // any operand. 3141eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson default: 314244ab89eb376af838d1123293a79975aede501464John Thompson weight = CW_Default; 3143eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson break; 3144eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson } 3145eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson return weight; 3146eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson} 3147eac6e1d0c748afc3d1496be0753ffbe5f5a4279bJohn Thompson 31484376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// ChooseConstraint - If there are multiple different constraints that we 31494376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// could pick for this operand (e.g. "imr") try to pick the 'best' one. 315024e1a9d3115a5bf4e1c21092ede0f6dfc0a810adChris Lattner/// This is somewhat tricky: constraints fall into four classes: 31514376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// Other -> immediates and magic values 31524376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// Register -> one specific register 31534376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// RegisterClass -> a group of regs 31544376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// Memory -> memory 31554376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// Ideally, we would pick the most specific constraint possible: if we have 31564376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// something that fits into a register, we would pick it. The problem here 31574376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// is that if we have something that could either be in a register or in 31584376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// memory that use of the register could cause selection of *other* 31594376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// operands to fail: they might only succeed if we pick memory. Because of 31604376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// this the heuristic we use is: 31614376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// 31624376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// 1) If there is an 'other' constraint, and if the operand is valid for 31634376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// that constraint, use it. This makes us take advantage of 'i' 31644376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// constraints when available. 31654376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// 2) Otherwise, pick the most general constraint present. This prefers 31664376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// 'm' over 'r', for example. 31674376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// 31684376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattnerstatic void ChooseConstraint(TargetLowering::AsmOperandInfo &OpInfo, 31691784d160e4efa75782884d451d0788b9457e67dcDale Johannesen const TargetLowering &TLI, 3170475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op, SelectionDAG *DAG) { 31714376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner assert(OpInfo.Codes.size() > 1 && "Doesn't have multiple constraint options"); 31724376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner unsigned BestIdx = 0; 31734376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner TargetLowering::ConstraintType BestType = TargetLowering::C_Unknown; 31744376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner int BestGenerality = -1; 3175a5989f8e222f6e2ad67704d7e8cc67c86c4d0697Dale Johannesen 31764376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner // Loop over the options, keeping track of the most general one. 31774376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner for (unsigned i = 0, e = OpInfo.Codes.size(); i != e; ++i) { 31784376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner TargetLowering::ConstraintType CType = 31794376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner TLI.getConstraintType(OpInfo.Codes[i]); 3180a5989f8e222f6e2ad67704d7e8cc67c86c4d0697Dale Johannesen 31815a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner // If this is an 'other' constraint, see if the operand is valid for it. 31825a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner // For example, on X86 we might have an 'rI' constraint. If the operand 31835a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner // is an integer in the range [0..31] we want to use I (saving a load 31845a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner // of a register), otherwise we must use 'r'. 3185ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (CType == TargetLowering::C_Other && Op.getNode()) { 31865a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner assert(OpInfo.Codes[i].size() == 1 && 31875a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner "Unhandled multi-letter 'other' constraint"); 3188475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::vector<SDValue> ResultOps; 3189100c83341676d8aae8fc34b5452563ed08b14f3eEric Christopher TLI.LowerAsmOperandForConstraint(Op, OpInfo.Codes[i], 31905a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner ResultOps, *DAG); 31915a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner if (!ResultOps.empty()) { 31925a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner BestType = CType; 31935a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner BestIdx = i; 31945a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner break; 31955a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner } 31965a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner } 3197bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 3198a5989f8e222f6e2ad67704d7e8cc67c86c4d0697Dale Johannesen // Things with matching constraints can only be registers, per gcc 3199a5989f8e222f6e2ad67704d7e8cc67c86c4d0697Dale Johannesen // documentation. This mainly affects "g" constraints. 3200a5989f8e222f6e2ad67704d7e8cc67c86c4d0697Dale Johannesen if (CType == TargetLowering::C_Memory && OpInfo.hasMatchingInput()) 3201a5989f8e222f6e2ad67704d7e8cc67c86c4d0697Dale Johannesen continue; 3202bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 32034376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner // This constraint letter is more general than the previous one, use it. 32044376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner int Generality = getConstraintGenerality(CType); 32054376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner if (Generality > BestGenerality) { 32064376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner BestType = CType; 32074376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner BestIdx = i; 32084376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner BestGenerality = Generality; 32094376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner } 32104376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner } 3211bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 32124376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner OpInfo.ConstraintCode = OpInfo.Codes[BestIdx]; 32134376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner OpInfo.ConstraintType = BestType; 32144376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner} 32154376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner 32164376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// ComputeConstraintToUse - Determines the constraint code and constraint 32174376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// type to use for the specific AsmOperandInfo, setting 32184376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner/// OpInfo.ConstraintCode and OpInfo.ConstraintType. 32195a09690446a36f94f990db7d18d9b9ac8587888aChris Lattnervoid TargetLowering::ComputeConstraintToUse(AsmOperandInfo &OpInfo, 3220bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue Op, 32215a09690446a36f94f990db7d18d9b9ac8587888aChris Lattner SelectionDAG *DAG) const { 32224376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner assert(!OpInfo.Codes.empty() && "Must have at least one constraint"); 3223bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 32244376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner // Single-letter constraints ('r') are very common. 32254376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner if (OpInfo.Codes.size() == 1) { 32264376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner OpInfo.ConstraintCode = OpInfo.Codes[0]; 32274376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner OpInfo.ConstraintType = getConstraintType(OpInfo.ConstraintCode); 32284376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner } else { 32291784d160e4efa75782884d451d0788b9457e67dcDale Johannesen ChooseConstraint(OpInfo, *this, Op, DAG); 32304376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner } 3231bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 32324376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner // 'X' matches anything. 32334376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner if (OpInfo.ConstraintCode == "X" && OpInfo.CallOperandVal) { 32344376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner // Labels and constants are handled elsewhere ('X' is the only thing 32358ea5ec681bd4838c84e545f8a1226a62d3b2f089Dale Johannesen // that matches labels). For Functions, the type here is the type of 32365339c551b508d8231672b417d9df1629e42af89bDale Johannesen // the result, which is not what we want to look at; leave them alone. 32375339c551b508d8231672b417d9df1629e42af89bDale Johannesen Value *v = OpInfo.CallOperandVal; 32388ea5ec681bd4838c84e545f8a1226a62d3b2f089Dale Johannesen if (isa<BasicBlock>(v) || isa<ConstantInt>(v) || isa<Function>(v)) { 32398ea5ec681bd4838c84e545f8a1226a62d3b2f089Dale Johannesen OpInfo.CallOperandVal = v; 32404376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner return; 32418ea5ec681bd4838c84e545f8a1226a62d3b2f089Dale Johannesen } 3242bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 32434376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner // Otherwise, try to resolve it to something we know about by looking at 32444376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner // the actual operand type. 32454376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner if (const char *Repl = LowerXConstraint(OpInfo.ConstraintVT)) { 32464376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner OpInfo.ConstraintCode = Repl; 32474376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner OpInfo.ConstraintType = getConstraintType(OpInfo.ConstraintCode); 32484376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner } 32494376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner } 32504376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner} 32514376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner 32524376fea6631d41fff3f2a7c6186faed9eff59619Chris Lattner//===----------------------------------------------------------------------===// 325330b37b5f29991874648d839d018aa2921b39355fEvan Cheng// Loop Strength Reduction hooks 325430b37b5f29991874648d839d018aa2921b39355fEvan Cheng//===----------------------------------------------------------------------===// 325530b37b5f29991874648d839d018aa2921b39355fEvan Cheng 32561436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner/// isLegalAddressingMode - Return true if the addressing mode represented 32571436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner/// by AM is legal for this target, for a load/store of the specified type. 3258bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckbool TargetLowering::isLegalAddressingMode(const AddrMode &AM, 3259db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) const { 32601436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner // The default implementation of this implements a conservative RISCy, r+r and 32611436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner // r+i addr mode. 32621436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner 32631436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner // Allows a sign-extended 16-bit immediate field. 32641436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner if (AM.BaseOffs <= -(1LL << 16) || AM.BaseOffs >= (1LL << 16)-1) 32651436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner return false; 3266bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 32671436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner // No global is ever allowed as a base. 32681436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner if (AM.BaseGV) 32691436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner return false; 3270bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 3271bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // Only support r+r, 32721436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner switch (AM.Scale) { 32731436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner case 0: // "r+i" or just "i", depending on HasBaseReg. 32741436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner break; 32751436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner case 1: 32761436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner if (AM.HasBaseReg && AM.BaseOffs) // "r+r+i" is not allowed. 32771436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner return false; 32781436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner // Otherwise we have r+r or r+i. 32791436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner break; 32801436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner case 2: 32811436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner if (AM.HasBaseReg || AM.BaseOffs) // 2*r+r or 2*r+i is not allowed. 32821436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner return false; 32831436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner // Allow 2*r as r+r. 32841436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner break; 32851436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner } 3286bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 32871436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner return true; 32881436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner} 32891436bb657d22b01fd9a526ee7f9b2cb880c064a7Chris Lattner 32909c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer/// BuildExactDiv - Given an exact SDIV by a constant, create a multiplication 32919c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer/// with the multiplicative inverse of the constant. 32929c64030445cbe6ac486b90c5f459f91e06770474Benjamin KramerSDValue TargetLowering::BuildExactSDIV(SDValue Op1, SDValue Op2, DebugLoc dl, 32939c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer SelectionDAG &DAG) const { 32949c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer ConstantSDNode *C = cast<ConstantSDNode>(Op2); 32959c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer APInt d = C->getAPIntValue(); 32969c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer assert(d != 0 && "Division by zero!"); 32979c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer 32989c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer // Shift the value upfront if it is even, so the LSB is one. 32999c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer unsigned ShAmt = d.countTrailingZeros(); 33009c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer if (ShAmt) { 33019c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer // TODO: For UDIV use SRL instead of SRA. 33029c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer SDValue Amt = DAG.getConstant(ShAmt, getShiftAmountTy(Op1.getValueType())); 33039c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer Op1 = DAG.getNode(ISD::SRA, dl, Op1.getValueType(), Op1, Amt); 33049c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer d = d.ashr(ShAmt); 33059c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer } 33069c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer 33079c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer // Calculate the multiplicative inverse, using Newton's method. 33089c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer APInt t, xn = d; 33099c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer while ((t = d*xn) != 1) 33109c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer xn *= APInt(d.getBitWidth(), 2) - t; 33119c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer 33129c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer Op2 = DAG.getConstant(xn, Op1.getValueType()); 33139c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer return DAG.getNode(ISD::MUL, dl, Op1.getValueType(), Op1, Op2); 33149c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer} 33159c64030445cbe6ac486b90c5f459f91e06770474Benjamin Kramer 3316dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// BuildSDIVSequence - Given an ISD::SDIV node expressing a divide by constant, 3317dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// return a DAG expression to select that will generate the same value by 3318dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// multiplying by a magic number. See: 3319dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// <http://the.wall.riscom.net/books/proc/ppc/cwg/code2.html> 332019a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard OsborneSDValue TargetLowering:: 332119a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard OsborneBuildSDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization, 332219a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne std::vector<SDNode*>* Created) const { 3323e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = N->getValueType(0); 3324ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen DebugLoc dl= N->getDebugLoc(); 3325bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 3326dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // Check to see if we can do this. 3327fc69cb475f3df50fb47c0cf8df90c2a77b7ff36aEli Friedman // FIXME: We should be more aggressive here. 3328fc69cb475f3df50fb47c0cf8df90c2a77b7ff36aEli Friedman if (!isTypeLegal(VT)) 3329fc69cb475f3df50fb47c0cf8df90c2a77b7ff36aEli Friedman return SDValue(); 3330bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 3331fc69cb475f3df50fb47c0cf8df90c2a77b7ff36aEli Friedman APInt d = cast<ConstantSDNode>(N->getOperand(1))->getAPIntValue(); 33324e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad APInt::ms magics = d.magic(); 3333bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 3334dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // Multiply the numerator (operand 0) by the magic value 3335fc69cb475f3df50fb47c0cf8df90c2a77b7ff36aEli Friedman // FIXME: We should support doing a MUL in a wider type 3336475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Q; 333719a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne if (IsAfterLegalization ? isOperationLegal(ISD::MULHS, VT) : 333819a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne isOperationLegalOrCustom(ISD::MULHS, VT)) 3339ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Q = DAG.getNode(ISD::MULHS, dl, VT, N->getOperand(0), 3340525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman DAG.getConstant(magics.m, VT)); 334119a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne else if (IsAfterLegalization ? isOperationLegal(ISD::SMUL_LOHI, VT) : 334219a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne isOperationLegalOrCustom(ISD::SMUL_LOHI, VT)) 3343ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Q = SDValue(DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(VT, VT), 3344525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman N->getOperand(0), 3345ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif DAG.getConstant(magics.m, VT)).getNode(), 1); 3346525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman else 3347475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(); // No mulhs or equvialent 3348dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // If d > 0 and m < 0, add the numerator 3349bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck if (d.isStrictlyPositive() && magics.m.isNegative()) { 3350ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Q = DAG.getNode(ISD::ADD, dl, VT, Q, N->getOperand(0)); 3351dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3352ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(Q.getNode()); 3353dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth } 3354dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // If d < 0 and m > 0, subtract the numerator. 3355fc69cb475f3df50fb47c0cf8df90c2a77b7ff36aEli Friedman if (d.isNegative() && magics.m.isStrictlyPositive()) { 3356ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen Q = DAG.getNode(ISD::SUB, dl, VT, Q, N->getOperand(0)); 3357dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3358ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(Q.getNode()); 3359dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth } 3360dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // Shift right algebraic if shift value is nonzero 3361dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (magics.s > 0) { 3362bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Q = DAG.getNode(ISD::SRA, dl, VT, Q, 336395771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(magics.s, getShiftAmountTy(Q.getValueType()))); 3364dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3365ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(Q.getNode()); 3366dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth } 3367dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // Extract the sign bit and add it to the quotient 3368475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue T = 3369ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen DAG.getNode(ISD::SRL, dl, VT, Q, DAG.getConstant(VT.getSizeInBits()-1, 337095771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson getShiftAmountTy(Q.getValueType()))); 3371dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3372ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(T.getNode()); 3373ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen return DAG.getNode(ISD::ADD, dl, VT, Q, T); 3374dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth} 3375dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth 3376dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// BuildUDIVSequence - Given an ISD::UDIV node expressing a divide by constant, 3377dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// return a DAG expression to select that will generate the same value by 3378dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// multiplying by a magic number. See: 3379dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth/// <http://the.wall.riscom.net/books/proc/ppc/cwg/code2.html> 338019a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard OsborneSDValue TargetLowering:: 338119a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard OsborneBuildUDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization, 338219a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne std::vector<SDNode*>* Created) const { 3383e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = N->getValueType(0); 3384ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen DebugLoc dl = N->getDebugLoc(); 3385201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman 3386dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // Check to see if we can do this. 3387201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman // FIXME: We should be more aggressive here. 3388201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman if (!isTypeLegal(VT)) 3389201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman return SDValue(); 3390201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman 3391201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman // FIXME: We should use a narrower constant when the upper 3392201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman // bits are known to be zero. 33931c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer const APInt &N1C = cast<ConstantSDNode>(N->getOperand(1))->getAPIntValue(); 33941c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer APInt::mu magics = N1C.magicu(); 33951c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer 33961c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer SDValue Q = N->getOperand(0); 33971c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer 33981c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer // If the divisor is even, we can avoid using the expensive fixup by shifting 33991c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer // the divided value upfront. 34001c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer if (magics.a != 0 && !N1C[0]) { 34011c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer unsigned Shift = N1C.countTrailingZeros(); 34021c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer Q = DAG.getNode(ISD::SRL, dl, VT, Q, 34031c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer DAG.getConstant(Shift, getShiftAmountTy(Q.getValueType()))); 34041c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer if (Created) 34051c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer Created->push_back(Q.getNode()); 34061c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer 34071c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer // Get magic number for the shifted divisor. 34081c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer magics = N1C.lshr(Shift).magicu(Shift); 34091c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer assert(magics.a == 0 && "Should use cheap fixup now"); 34101c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer } 3411201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman 3412dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth // Multiply the numerator (operand 0) by the magic value 3413201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman // FIXME: We should support doing a MUL in a wider type 341419a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne if (IsAfterLegalization ? isOperationLegal(ISD::MULHU, VT) : 341519a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne isOperationLegalOrCustom(ISD::MULHU, VT)) 34161c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer Q = DAG.getNode(ISD::MULHU, dl, VT, Q, DAG.getConstant(magics.m, VT)); 341719a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne else if (IsAfterLegalization ? isOperationLegal(ISD::UMUL_LOHI, VT) : 341819a4daff9bbe18dab2620e25ac6cbf0635639ec6Richard Osborne isOperationLegalOrCustom(ISD::UMUL_LOHI, VT)) 34191c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer Q = SDValue(DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(VT, VT), Q, 34201c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer DAG.getConstant(magics.m, VT)).getNode(), 1); 3421525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman else 3422475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(); // No mulhu or equvialent 3423dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3424ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(Q.getNode()); 3425dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth 3426dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (magics.a == 0) { 34271c10b8de46ce8e39178eeded4786b1e53722f099Benjamin Kramer assert(magics.s < N1C.getBitWidth() && 3428201c9776bd4197569b71fef0519f98a28d1db989Eli Friedman "We shouldn't generate an undefined shift!"); 3429bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getNode(ISD::SRL, dl, VT, Q, 343095771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(magics.s, getShiftAmountTy(Q.getValueType()))); 3431dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth } else { 3432ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen SDValue NPQ = DAG.getNode(ISD::SUB, dl, VT, N->getOperand(0), Q); 3433dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3434ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(NPQ.getNode()); 3435bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck NPQ = DAG.getNode(ISD::SRL, dl, VT, NPQ, 343695771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(1, getShiftAmountTy(NPQ.getValueType()))); 3437dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3438ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(NPQ.getNode()); 3439ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen NPQ = DAG.getNode(ISD::ADD, dl, VT, NPQ, Q); 3440dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth if (Created) 3441ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Created->push_back(NPQ.getNode()); 3442bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck return DAG.getNode(ISD::SRL, dl, VT, NPQ, 344395771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(magics.s-1, getShiftAmountTy(NPQ.getValueType()))); 3444dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth } 3445dae9cbe8d4fcd8f182a99403d67cae906bdb3175Andrew Lenharth} 3446