SelectionDAGISel.cpp revision 6e7a1617ac4a34792d9097b8d3644b72f57a45f7
11c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===-- SelectionDAGISel.cpp - Implement the SelectionDAGISel class -------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 31c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// The LLVM Compiler Infrastructure 41c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 81c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 91c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// This implements the SelectionDAGISel class. 111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define DEBUG_TYPE "isel" 15381cb07544a2bc119e39969d7d508a6247773e1cEvan Cheng#include "llvm/CodeGen/SelectionDAGISel.h" 16f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman#include "SelectionDAGBuild.h" 17c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey#include "llvm/Analysis/AliasAnalysis.h" 185502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov#include "llvm/Constants.h" 19adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 2236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner#include "llvm/GlobalVariable.h" 23ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner#include "llvm/InlineAsm.h" 241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 2643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey#include "llvm/IntrinsicInst.h" 2778eca170e9ac5db7fd525f9bbf27090fefcbb646Dan Gohman#include "llvm/CodeGen/FastISel.h" 285a29c9eed157af51a8d338b5a225b146881819e8Gordon Henriksen#include "llvm/CodeGen/GCStrategy.h" 295eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen#include "llvm/CodeGen/GCMetadata.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 3384bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineJumpTableInfo.h" 3484bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 3584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 36343f0c046702831a4a6aec951b6a297a23241a55Dan Gohman#include "llvm/CodeGen/ScheduleDAGSDNodes.h" 37eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey#include "llvm/CodeGen/SchedulerRegistry.h" 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 396e7a1617ac4a34792d9097b8d3644b72f57a45f7Devang Patel#include "llvm/CodeGen/DwarfWriter.h" 406f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman#include "llvm/Target/TargetRegisterInfo.h" 411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 46124729155d860a0850eb4ef2a7cea4145e13a057Vladimir Prus#include "llvm/Target/TargetOptions.h" 47a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 48db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng#include "llvm/Support/Debug.h" 49db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng#include "llvm/Support/MathExtras.h" 50db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng#include "llvm/Support/Timer.h" 517e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 54ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattnerstatic cl::opt<bool> 5570587ea813986bb0dbef71610091d496e28c22a6Chris LattnerEnableValueProp("enable-value-prop", cl::Hidden); 5670587ea813986bb0dbef71610091d496e28c22a6Chris Lattnerstatic cl::opt<bool> 577cb07874dcadaa9a5082a80959cd15d44ba3a133Duncan SandsDisableLegalizeTypes("disable-legalize-types", cl::Hidden); 58727809ad8a826f26b757747ae2a329b49e5449b3Dan Gohman#ifndef NDEBUG 5978eca170e9ac5db7fd525f9bbf27090fefcbb646Dan Gohmanstatic cl::opt<bool> 60293d5f8bc02a9148238b2c79484637f56de65b9cDan GohmanEnableFastISelVerbose("fast-isel-verbose", cl::Hidden, 61d659d50482e2f9edf8f436e4a1aa30c68c6d020bDan Gohman cl::desc("Enable verbose messages in the \"fast\" " 62293d5f8bc02a9148238b2c79484637f56de65b9cDan Gohman "instruction selector")); 63293d5f8bc02a9148238b2c79484637f56de65b9cDan Gohmanstatic cl::opt<bool> 644344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan GohmanEnableFastISelAbort("fast-isel-abort", cl::Hidden, 654344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan Gohman cl::desc("Enable abort calls when \"fast\" instruction fails")); 662275105edbee89df8f5a68655ee75c9a5f169dbbDan Gohman#else 672275105edbee89df8f5a68655ee75c9a5f169dbbDan Gohmanstatic const bool EnableFastISelVerbose = false, 682275105edbee89df8f5a68655ee75c9a5f169dbbDan Gohman EnableFastISelAbort = false; 69727809ad8a826f26b757747ae2a329b49e5449b3Dan Gohman#endif 708a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohmanstatic cl::opt<bool> 718a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan GohmanSchedLiveInCopies("schedule-livein-copies", 728a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman cl::desc("Schedule copies of livein registers"), 738a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman cl::init(false)); 74ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 75da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 767944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 77462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan GohmanViewDAGCombine1("view-dag-combine1-dags", cl::Hidden, 78462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman cl::desc("Pop up a window to show dags before the first " 79462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman "dag combine pass")); 80462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohmanstatic cl::opt<bool> 81462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan GohmanViewLegalizeTypesDAGs("view-legalize-types-dags", cl::Hidden, 82462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman cl::desc("Pop up a window to show dags before legalize types")); 83462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohmanstatic cl::opt<bool> 84462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan GohmanViewLegalizeDAGs("view-legalize-dags", cl::Hidden, 85462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman cl::desc("Pop up a window to show dags before legalize")); 86462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohmanstatic cl::opt<bool> 87462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan GohmanViewDAGCombine2("view-dag-combine2-dags", cl::Hidden, 88462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman cl::desc("Pop up a window to show dags before the second " 89462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman "dag combine pass")); 90462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohmanstatic cl::opt<bool> 9125cf2275ff7de3de3bc0e508abaf457413d74725Duncan SandsViewDAGCombineLT("view-dag-combine-lt-dags", cl::Hidden, 9225cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands cl::desc("Pop up a window to show dags before the post legalize types" 9325cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands " dag combine pass")); 9425cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sandsstatic cl::opt<bool> 95a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 96a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 97a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 98a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 99a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 1003e1a7aef17575d9c7058a035449d57e3c7295ed0Dan Gohmanstatic cl::opt<bool> 1013e1a7aef17575d9c7058a035449d57e3c7295ed0Dan GohmanViewSUnitDAGs("view-sunit-dags", cl::Hidden, 1025bab78527a946632cd9614daa0b9a82ee7b5e1ccChris Lattner cl::desc("Pop up a window to show SUnit dags after they are processed")); 1037944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 104462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohmanstatic const bool ViewDAGCombine1 = false, 105462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman ViewLegalizeTypesDAGs = false, ViewLegalizeDAGs = false, 106462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman ViewDAGCombine2 = false, 10725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands ViewDAGCombineLT = false, 108462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman ViewISelDAGs = false, ViewSchedDAGs = false, 109462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman ViewSUnitDAGs = false; 1107944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 1117944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 112eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 113eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 114eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// RegisterScheduler class - Track the registration of instruction schedulers. 115eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 116eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 117eb577ba3b815a1fa4627b060dd2345d17abf672dJim LaskeyMachinePassRegistry RegisterScheduler::Registry; 118eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 119eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 120eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 121eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// ISHeuristic command line option for instruction schedulers. 122eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 123eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 124844731a7f1909f55935e3514c9e713a62d67662eDan Gohmanstatic cl::opt<RegisterScheduler::FunctionPassCtor, false, 125844731a7f1909f55935e3514c9e713a62d67662eDan Gohman RegisterPassParser<RegisterScheduler> > 126844731a7f1909f55935e3514c9e713a62d67662eDan GohmanISHeuristic("pre-RA-sched", 127844731a7f1909f55935e3514c9e713a62d67662eDan Gohman cl::init(&createDefaultScheduler), 128844731a7f1909f55935e3514c9e713a62d67662eDan Gohman cl::desc("Instruction schedulers available (before register" 129844731a7f1909f55935e3514c9e713a62d67662eDan Gohman " allocation):")); 13013ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 131844731a7f1909f55935e3514c9e713a62d67662eDan Gohmanstatic RegisterScheduler 132b8cab9227a0f6ffbdaae33e3c64268e265008a6aDan GohmandefaultListDAGScheduler("default", "Best scheduler for the target", 133844731a7f1909f55935e3514c9e713a62d67662eDan Gohman createDefaultScheduler); 1344ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 135f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohmannamespace llvm { 136f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman //===--------------------------------------------------------------------===// 137f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman /// createDefaultScheduler - This creates an instruction scheduler appropriate 138f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman /// for the target. 139f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman ScheduleDAG* createDefaultScheduler(SelectionDAGISel *IS, 140f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman SelectionDAG *DAG, 1419b75b373756288cd39489da7994207f50b31ee40Dan Gohman const TargetMachine *TM, 142f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman MachineBasicBlock *BB, 143f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman bool Fast) { 144f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman TargetLowering &TLI = IS->getTargetLowering(); 145e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 1469e76fea3abd4229749e6ead46a0016cabff4a056Dan Gohman if (Fast) 1479e76fea3abd4229749e6ead46a0016cabff4a056Dan Gohman return createFastDAGScheduler(IS, DAG, TM, BB, Fast); 1489e76fea3abd4229749e6ead46a0016cabff4a056Dan Gohman if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) 1499b75b373756288cd39489da7994207f50b31ee40Dan Gohman return createTDListDAGScheduler(IS, DAG, TM, BB, Fast); 1509e76fea3abd4229749e6ead46a0016cabff4a056Dan Gohman assert(TLI.getSchedulingPreference() == 1519e76fea3abd4229749e6ead46a0016cabff4a056Dan Gohman TargetLowering::SchedulingForRegPressure && "Unknown sched type!"); 1529e76fea3abd4229749e6ead46a0016cabff4a056Dan Gohman return createBURRListDAGScheduler(IS, DAG, TM, BB, Fast); 1533a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner } 1541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 156ff9b373e8f5006c629af81e2619778b4c4f5249eEvan Cheng// EmitInstrWithCustomInserter - This method should be implemented by targets 157ff9b373e8f5006c629af81e2619778b4c4f5249eEvan Cheng// that mark instructions with the 'usesCustomDAGSchedInserter' flag. These 158025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 159025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 160025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 161ff9b373e8f5006c629af81e2619778b4c4f5249eEvan ChengMachineBasicBlock *TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI, 162025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 163832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "If a target marks an instruction with " 164832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << "'usesCustomDAGSchedInserter', it must implement " 165ff9b373e8f5006c629af81e2619778b4c4f5249eEvan Cheng << "TargetLowering::EmitInstrWithCustomInserter!\n"; 166025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 167025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 168025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 169025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 1708a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman/// EmitLiveInCopy - Emit a copy for a live in physical register. If the 1718a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman/// physical register has only a single copy use, then coalesced the copy 1728a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman/// if possible. 1738a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohmanstatic void EmitLiveInCopy(MachineBasicBlock *MBB, 1748a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MachineBasicBlock::iterator &InsertPos, 1758a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman unsigned VirtReg, unsigned PhysReg, 1768a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetRegisterClass *RC, 1778a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman DenseMap<MachineInstr*, unsigned> &CopyRegMap, 1788a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const MachineRegisterInfo &MRI, 1798a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetRegisterInfo &TRI, 1808a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetInstrInfo &TII) { 1818a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman unsigned NumUses = 0; 1828a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MachineInstr *UseMI = NULL; 1838a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman for (MachineRegisterInfo::use_iterator UI = MRI.use_begin(VirtReg), 1848a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman UE = MRI.use_end(); UI != UE; ++UI) { 1858a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman UseMI = &*UI; 1868a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (++NumUses > 1) 1878a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman break; 1888a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } 1898a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman 1908a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // If the number of uses is not one, or the use is not a move instruction, 1918a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // don't coalesce. Also, only coalesce away a virtual register to virtual 1928a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // register copy. 1938a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman bool Coalesced = false; 1948a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman unsigned SrcReg, DstReg; 1958a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (NumUses == 1 && 1968a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman TII.isMoveInstr(*UseMI, SrcReg, DstReg) && 1978a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman TargetRegisterInfo::isVirtualRegister(DstReg)) { 1988a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman VirtReg = DstReg; 1998a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman Coalesced = true; 2008a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } 2018a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman 2028a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // Now find an ideal location to insert the copy. 2038a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MachineBasicBlock::iterator Pos = InsertPos; 2048a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman while (Pos != MBB->begin()) { 2058a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MachineInstr *PrevMI = prior(Pos); 2068a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman DenseMap<MachineInstr*, unsigned>::iterator RI = CopyRegMap.find(PrevMI); 2078a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // copyRegToReg might emit multiple instructions to do a copy. 2088a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman unsigned CopyDstReg = (RI == CopyRegMap.end()) ? 0 : RI->second; 2098a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (CopyDstReg && !TRI.regsOverlap(CopyDstReg, PhysReg)) 2108a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // This is what the BB looks like right now: 2118a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // r1024 = mov r0 2128a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // ... 2138a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // r1 = mov r1024 2148a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // 2158a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // We want to insert "r1025 = mov r1". Inserting this copy below the 2168a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // move to r1024 makes it impossible for that move to be coalesced. 2178a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // 2188a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // r1025 = mov r1 2198a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // r1024 = mov r0 2208a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // ... 2218a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // r1 = mov 1024 2228a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // r2 = mov 1025 2238a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman break; // Woot! Found a good location. 2248a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman --Pos; 2258a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } 2268a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman 2278a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman TII.copyRegToReg(*MBB, Pos, VirtReg, PhysReg, RC, RC); 2288a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman CopyRegMap.insert(std::make_pair(prior(Pos), VirtReg)); 2298a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (Coalesced) { 2308a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (&*InsertPos == UseMI) ++InsertPos; 2318a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MBB->erase(UseMI); 2328a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } 2338a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman} 2348a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman 2358a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman/// EmitLiveInCopies - If this is the first basic block in the function, 2368a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman/// and if it has live ins that need to be copied into vregs, emit the 2378a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman/// copies into the block. 2388a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohmanstatic void EmitLiveInCopies(MachineBasicBlock *EntryMBB, 2398a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const MachineRegisterInfo &MRI, 2408a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetRegisterInfo &TRI, 2418a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetInstrInfo &TII) { 2428a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (SchedLiveInCopies) { 2438a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // Emit the copies at a heuristically-determined location in the block. 2448a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman DenseMap<MachineInstr*, unsigned> CopyRegMap; 2458a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MachineBasicBlock::iterator InsertPos = EntryMBB->begin(); 2468a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman for (MachineRegisterInfo::livein_iterator LI = MRI.livein_begin(), 2478a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman E = MRI.livein_end(); LI != E; ++LI) 2488a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (LI->second) { 2498a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetRegisterClass *RC = MRI.getRegClass(LI->second); 2508a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman EmitLiveInCopy(EntryMBB, InsertPos, LI->second, LI->first, 2518a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman RC, CopyRegMap, MRI, TRI, TII); 2528a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } 2538a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } else { 2548a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // Emit the copies into the top of the block. 2558a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman for (MachineRegisterInfo::livein_iterator LI = MRI.livein_begin(), 2568a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman E = MRI.livein_end(); LI != E; ++LI) 2578a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman if (LI->second) { 2588a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetRegisterClass *RC = MRI.getRegClass(LI->second); 2598a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman TII.copyRegToReg(*EntryMBB, EntryMBB->begin(), 2608a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman LI->second, LI->first, RC, RC); 2618a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } 2628a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman } 2638a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman} 2648a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman 2657041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 2667041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 2677041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 2681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2697c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan GohmanSelectionDAGISel::SelectionDAGISel(TargetLowering &tli, bool fast) : 270ae73dc1448d25b02cabc7c64c86c64371453dda8Dan Gohman FunctionPass(&ID), TLI(tli), 2717c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman FuncInfo(new FunctionLoweringInfo(TLI)), 2727c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman CurDAG(new SelectionDAG(TLI, *FuncInfo)), 2737c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL(new SelectionDAGLowering(*CurDAG, TLI, *FuncInfo)), 2747c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman GFI(), 2757c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman Fast(fast), 2767c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman DAGSize(0) 2777c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman{} 2787c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman 2797c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan GohmanSelectionDAGISel::~SelectionDAGISel() { 2807c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman delete SDL; 2817c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman delete CurDAG; 2827c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman delete FuncInfo; 2837c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman} 2847c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman 28583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sandsunsigned SelectionDAGISel::MakeReg(MVT VT) { 28684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner return RegInfo->createVirtualRegister(TLI.getRegClassFor(VT)); 2871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 289495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 290c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AU.addRequired<AliasAnalysis>(); 2915eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen AU.addRequired<GCModuleInfo>(); 2926e7a1617ac4a34792d9097b8d3644b72f57a45f7Devang Patel AU.addRequired<DwarfWriter>(); 293c8d288f8fa9e46199a29e1954550c980f184bd1cChris Lattner AU.setPreservesAll(); 294495a0b51915eb763576874f29192820b731edc22Chris Lattner} 2951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 2974344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan Gohman // Do some sanity-checking on the command-line options. 2984344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan Gohman assert((!EnableFastISelVerbose || EnableFastISel) && 2994344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan Gohman "-fast-isel-verbose requires -fast-isel"); 3004344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan Gohman assert((!EnableFastISelAbort || EnableFastISel) && 3014344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan Gohman "-fast-isel-abort requires -fast-isel"); 3024344a5d0d7b280f0b891e0e6a4413b059d9080b3Dan Gohman 3035f43f92c69aae9837064cf08291db1b36a82789fDan Gohman // Get alias analysis for load/store combining. 3045f43f92c69aae9837064cf08291db1b36a82789fDan Gohman AA = &getAnalysis<AliasAnalysis>(); 3055f43f92c69aae9837064cf08291db1b36a82789fDan Gohman 3068a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman TargetMachine &TM = TLI.getTargetMachine(); 3078a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MachineFunction &MF = MachineFunction::construct(&Fn, TM); 3088a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const MachineRegisterInfo &MRI = MF.getRegInfo(); 3098a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetInstrInfo &TII = *TM.getInstrInfo(); 3108a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman const TargetRegisterInfo &TRI = *TM.getRegisterInfo(); 3118a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman 3125eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (MF.getFunction()->hasGC()) 3135eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GFI = &getAnalysis<GCModuleInfo>().getFunctionInfo(*MF.getFunction()); 314ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen else 3155eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GFI = 0; 31684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner RegInfo = &MF.getRegInfo(); 317832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "\n\n\n=== " << Fn.getName() << "\n"; 3181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 319f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman FuncInfo->set(Fn, MF, EnableFastISel); 320d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman MachineModuleInfo *MMI = getAnalysisToUpdate<MachineModuleInfo>(); 3216e7a1617ac4a34792d9097b8d3644b72f57a45f7Devang Patel DwarfWriter *DW = getAnalysisToUpdate<DwarfWriter>(); 3226e7a1617ac4a34792d9097b8d3644b72f57a45f7Devang Patel CurDAG->init(MF, MMI, DW); 3237c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->init(GFI, *AA); 3241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3251532f3ddd77c362dd5f613af06b4de636e3c5b0eDale Johannesen for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 3261532f3ddd77c362dd5f613af06b4de636e3c5b0eDale Johannesen if (InvokeInst *Invoke = dyn_cast<InvokeInst>(I->getTerminator())) 3271532f3ddd77c362dd5f613af06b4de636e3c5b0eDale Johannesen // Mark landing pad. 3287c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman FuncInfo->MBBMap[Invoke->getSuccessor(1)]->setIsLandingPad(); 3299fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands 330dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman SelectAllBasicBlocks(Fn, MF, MMI, TII); 331edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3328a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // If the first basic block in the function has live ins that need to be 3338a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // copied into vregs, emit the copies into the top of the block before 3348a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman // emitting the code for the block. 3358a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman EmitLiveInCopies(MF.begin(), MRI, TRI, TII); 3368a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman 337ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng // Add function live-ins to entry block live-in set. 3388a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman for (MachineRegisterInfo::livein_iterator I = RegInfo->livein_begin(), 3398a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman E = RegInfo->livein_end(); I != E; ++I) 3408a11053f3ca7efb29312c4293c4fdb5d2ca3e20fDan Gohman MF.begin()->addLiveIn(I->first); 341ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng 342f40708223e409a152834b1553c6883ff2035b957Duncan Sands#ifndef NDEBUG 3437c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman assert(FuncInfo->CatchInfoFound.size() == FuncInfo->CatchInfoLost.size() && 344f40708223e409a152834b1553c6883ff2035b957Duncan Sands "Not all catch info was assigned to a landing pad!"); 345f40708223e409a152834b1553c6883ff2035b957Duncan Sands#endif 346f40708223e409a152834b1553c6883ff2035b957Duncan Sands 3477c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman FuncInfo->clear(); 3487c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman 3491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 3501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 3511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 352f40708223e409a152834b1553c6883ff2035b957Duncan Sandsstatic void copyCatchInfo(BasicBlock *SrcBB, BasicBlock *DestBB, 353f40708223e409a152834b1553c6883ff2035b957Duncan Sands MachineModuleInfo *MMI, FunctionLoweringInfo &FLI) { 354f40708223e409a152834b1553c6883ff2035b957Duncan Sands for (BasicBlock::iterator I = SrcBB->begin(), E = --SrcBB->end(); I != E; ++I) 355f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman if (EHSelectorInst *EHSel = dyn_cast<EHSelectorInst>(I)) { 356f40708223e409a152834b1553c6883ff2035b957Duncan Sands // Apply the catch info to DestBB. 357f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman AddCatchInfo(*EHSel, MMI, FLI.MBBMap[DestBB]); 358f40708223e409a152834b1553c6883ff2035b957Duncan Sands#ifndef NDEBUG 359560a737e073788463b9275c5e92ebc12f0ea62a2Duncan Sands if (!FLI.MBBMap[SrcBB]->isLandingPad()) 360f0cbcd48804961b05359ee41859bbd7774f41fe0Dan Gohman FLI.CatchInfoFound.insert(EHSel); 361f40708223e409a152834b1553c6883ff2035b957Duncan Sands#endif 362f40708223e409a152834b1553c6883ff2035b957Duncan Sands } 363f40708223e409a152834b1553c6883ff2035b957Duncan Sands} 364f40708223e409a152834b1553c6883ff2035b957Duncan Sands 36530e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer/// IsFixedFrameObjectWithPosOffset - Check if object is a fixed frame object and 36630e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer/// whether object offset >= 0. 36730e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighoferstatic bool 368475871a144eb604ddaf37503397ba0941442e5fbDan GohmanIsFixedFrameObjectWithPosOffset(MachineFrameInfo * MFI, SDValue Op) { 36930e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer if (!isa<FrameIndexSDNode>(Op)) return false; 37030e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer 37130e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer FrameIndexSDNode * FrameIdxNode = dyn_cast<FrameIndexSDNode>(Op); 37230e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer int FrameIdx = FrameIdxNode->getIndex(); 37330e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer return MFI->isFixedObjectIndex(FrameIdx) && 37430e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer MFI->getObjectOffset(FrameIdx) >= 0; 37530e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer} 37630e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer 37730e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer/// IsPossiblyOverwrittenArgumentOfTailCall - Check if the operand could 37830e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer/// possibly be overwritten when lowering the outgoing arguments in a tail 37930e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer/// call. Currently the implementation of this call is very conservative and 38030e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer/// assumes all arguments sourcing from FORMAL_ARGUMENTS or a CopyFromReg with 38130e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer/// virtual registers would be overwritten by direct lowering. 382475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic bool IsPossiblyOverwrittenArgumentOfTailCall(SDValue Op, 38330e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer MachineFrameInfo * MFI) { 38430e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer RegisterSDNode * OpReg = NULL; 38530e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer if (Op.getOpcode() == ISD::FORMAL_ARGUMENTS || 38630e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer (Op.getOpcode()== ISD::CopyFromReg && 38730e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer (OpReg = dyn_cast<RegisterSDNode>(Op.getOperand(1))) && 38830e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer (OpReg->getReg() >= TargetRegisterInfo::FirstVirtualRegister)) || 38930e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer (Op.getOpcode() == ISD::LOAD && 39030e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer IsFixedFrameObjectWithPosOffset(MFI, Op.getOperand(1))) || 39130e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer (Op.getOpcode() == ISD::MERGE_VALUES && 39299a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif Op.getOperand(Op.getResNo()).getOpcode() == ISD::LOAD && 39399a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif IsFixedFrameObjectWithPosOffset(MFI, Op.getOperand(Op.getResNo()). 39430e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer getOperand(1)))) 39530e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer return true; 39630e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer return false; 39730e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer} 39830e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer 399c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer/// CheckDAGForTailCallsAndFixThem - This Function looks for CALL nodes in the 40048abc5cf6ba6d53513034aa8c68b0a9abd748190Arnold Schwaighofer/// DAG and fixes their tailcall attribute operand. 401c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighoferstatic void CheckDAGForTailCallsAndFixThem(SelectionDAG &DAG, 402c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer TargetLowering& TLI) { 403c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer SDNode * Ret = NULL; 404475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Terminator = DAG.getRoot(); 405c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 406c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // Find RET node. 407c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer if (Terminator.getOpcode() == ISD::RET) { 408ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Ret = Terminator.getNode(); 409c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 410c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 411c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // Fix tail call attribute of CALL nodes. 412c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer for (SelectionDAG::allnodes_iterator BE = DAG.allnodes_begin(), 4130e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman BI = DAG.allnodes_end(); BI != BE; ) { 4140e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman --BI; 415095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman if (CallSDNode *TheCall = dyn_cast<CallSDNode>(BI)) { 416475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OpRet(Ret, 0); 417475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OpCall(BI, 0); 418095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman bool isMarkedTailCall = TheCall->isTailCall(); 419c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // If CALL node has tail call attribute set to true and the call is not 420c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // eligible (no RET or the target rejects) the attribute is fixed to 42148abc5cf6ba6d53513034aa8c68b0a9abd748190Arnold Schwaighofer // false. The TargetLowering::IsEligibleForTailCallOptimization function 422c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // must correctly identify tail call optimizable calls. 42330e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer if (!isMarkedTailCall) continue; 42430e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer if (Ret==NULL || 425095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman !TLI.IsEligibleForTailCallOptimization(TheCall, OpRet, DAG)) { 426095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman // Not eligible. Mark CALL node as non tail call. Note that we 427095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman // can modify the call node in place since calls are not CSE'd. 428095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman TheCall->setNotTailCall(); 42930e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer } else { 43030e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer // Look for tail call clobbered arguments. Emit a series of 43130e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer // copyto/copyfrom virtual register nodes to protect them. 432475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 32> Ops; 433095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman SDValue Chain = TheCall->getChain(), InFlag; 434095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman Ops.push_back(Chain); 435095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman Ops.push_back(TheCall->getCallee()); 436095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; ++i) { 437095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman SDValue Arg = TheCall->getArg(i); 438095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman bool isByVal = TheCall->getArgFlags(i).isByVal(); 439095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman MachineFunction &MF = DAG.getMachineFunction(); 440095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman MachineFrameInfo *MFI = MF.getFrameInfo(); 441095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman if (!isByVal && 442095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman IsPossiblyOverwrittenArgumentOfTailCall(Arg, MFI)) { 443095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman MVT VT = Arg.getValueType(); 444095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman unsigned VReg = MF.getRegInfo(). 445095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman createVirtualRegister(TLI.getRegClassFor(VT)); 446095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman Chain = DAG.getCopyToReg(Chain, VReg, Arg, InFlag); 447095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman InFlag = Chain.getValue(1); 448095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman Arg = DAG.getCopyFromReg(Chain, VReg, VT, InFlag); 449095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman Chain = Arg.getValue(1); 450095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman InFlag = Arg.getValue(2); 45130e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer } 45230e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer Ops.push_back(Arg); 453095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman Ops.push_back(TheCall->getArgFlagsVal(i)); 45430e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer } 45530e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer // Link in chain of CopyTo/CopyFromReg. 45630e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer Ops[0] = Chain; 45730e62c098b5841259f8026df1c5c45c7c1182a38Arnold Schwaighofer DAG.UpdateNodeOperands(OpCall, Ops.begin(), Ops.size()); 458c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 459c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 460c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 461c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer} 462c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 463f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohmanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, 464f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman BasicBlock::iterator Begin, 4655edd361497f4c78a20fcbb75c6e7e94ff8046ed1Dan Gohman BasicBlock::iterator End) { 4667c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->setCurrentBasicBlock(BB); 467f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 468f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman // Lower all of the non-terminator instructions. 469f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman for (BasicBlock::iterator I = Begin; I != End; ++I) 470f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (!isa<TerminatorInst>(I)) 4717c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->visit(*I); 472f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 473f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman // Ensure that all instructions which are used outside of their defining 474f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman // blocks are available as virtual registers. Invoke is handled elsewhere. 475f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman for (BasicBlock::iterator I = Begin; I != End; ++I) 476f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (!I->use_empty() && !isa<PHINode>(I) && !isa<InvokeInst>(I)) { 4777c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman DenseMap<const Value*,unsigned>::iterator VMI =FuncInfo->ValueMap.find(I); 4787c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (VMI != FuncInfo->ValueMap.end()) 4797c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->CopyValueToVirtualRegister(I, VMI->second); 480f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 481f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 482f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman // Handle PHI nodes in successor blocks. 4833df24e667f04a7003342b534310919abc9c87418Dan Gohman if (End == LLVMBB->end()) { 4847c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman HandlePHINodesInSuccessorBlocks(LLVMBB); 4853df24e667f04a7003342b534310919abc9c87418Dan Gohman 4863df24e667f04a7003342b534310919abc9c87418Dan Gohman // Lower the terminator after the copies are emitted. 4873df24e667f04a7003342b534310919abc9c87418Dan Gohman SDL->visit(*LLVMBB->getTerminator()); 4883df24e667f04a7003342b534310919abc9c87418Dan Gohman } 4894198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 490a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 4917c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman CurDAG->setRoot(SDL->getControlRoot()); 492c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 493c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // Check whether calls in this block are real tail calls. Fix up CALL nodes 494c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // with correct tailcall attribute so that the target can rely on the tailcall 495c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // attribute indicating whether the call is really eligible for tail call 496c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // optimization. 4971937e2f6ca0e6a04c4ad5fdb5b606b5ed9533e74Dan Gohman if (PerformTailCallOpt) 4981937e2f6ca0e6a04c4ad5fdb5b606b5ed9533e74Dan Gohman CheckDAGForTailCallsAndFixThem(*CurDAG, TLI); 499f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 500f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman // Final step, emit the lowered DAG as machine code. 501f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CodeGenAndEmitDAG(); 5027c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->clear(); 5031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 505f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohmanvoid SelectionDAGISel::ComputeLiveOutVRegInfo() { 506ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner SmallPtrSet<SDNode*, 128> VisitedNodes; 507ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner SmallVector<SDNode*, 128> Worklist; 508ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 509ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Worklist.push_back(CurDAG->getRoot().getNode()); 510ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 511ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner APInt Mask; 512ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner APInt KnownZero; 513ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner APInt KnownOne; 514ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 515ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner while (!Worklist.empty()) { 516ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner SDNode *N = Worklist.back(); 517ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner Worklist.pop_back(); 518ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 519ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner // If we've already seen this node, ignore it. 520ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner if (!VisitedNodes.insert(N)) 521ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner continue; 522ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 523ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner // Otherwise, add all chain operands to the worklist. 524ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 525ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner if (N->getOperand(i).getValueType() == MVT::Other) 526ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Worklist.push_back(N->getOperand(i).getNode()); 527ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 528ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner // If this is a CopyToReg with a vreg dest, process it. 529ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner if (N->getOpcode() != ISD::CopyToReg) 530ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner continue; 531ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 532ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner unsigned DestReg = cast<RegisterSDNode>(N->getOperand(1))->getReg(); 533ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner if (!TargetRegisterInfo::isVirtualRegister(DestReg)) 534ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner continue; 535ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 536ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner // Ignore non-scalar or non-integer values. 537475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Src = N->getOperand(2); 538ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner MVT SrcVT = Src.getValueType(); 539ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner if (!SrcVT.isInteger() || SrcVT.isVector()) 540ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner continue; 541ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 542f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman unsigned NumSignBits = CurDAG->ComputeNumSignBits(Src); 543ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner Mask = APInt::getAllOnesValue(SrcVT.getSizeInBits()); 544f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CurDAG->ComputeMaskedBits(Src, Mask, KnownZero, KnownOne); 545ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 546ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner // Only install this information if it tells us something. 547ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner if (NumSignBits != 1 || KnownZero != 0 || KnownOne != 0) { 548ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner DestReg -= TargetRegisterInfo::FirstVirtualRegister; 549f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman FunctionLoweringInfo &FLI = CurDAG->getFunctionLoweringInfo(); 550ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner if (DestReg >= FLI.LiveOutRegInfo.size()) 551ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner FLI.LiveOutRegInfo.resize(DestReg+1); 552ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner FunctionLoweringInfo::LiveOutInfo &LOI = FLI.LiveOutRegInfo[DestReg]; 553ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner LOI.NumSignBits = NumSignBits; 554ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner LOI.KnownOne = NumSignBits; 555ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner LOI.KnownZero = NumSignBits; 556ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner } 557ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner } 558ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner} 559ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 560f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohmanvoid SelectionDAGISel::CodeGenAndEmitDAG() { 561462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman std::string GroupName; 562462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman if (TimePassesIsEnabled) 563462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman GroupName = "Instruction Selection and Scheduling"; 564462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman std::string BlockName; 565462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman if (ViewDAGCombine1 || ViewLegalizeTypesDAGs || ViewLegalizeDAGs || 56625cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands ViewDAGCombine2 || ViewDAGCombineLT || ViewISelDAGs || ViewSchedDAGs || 56725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands ViewSUnitDAGs) 568f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman BlockName = CurDAG->getMachineFunction().getFunction()->getName() + ':' + 569462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman BB->getBasicBlock()->getName(); 570462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 571462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman DOUT << "Initial selection DAG:\n"; 572f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DEBUG(CurDAG->dump()); 573462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 574f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (ViewDAGCombine1) CurDAG->viewGraph("dag-combine1 input for " + BlockName); 575417e11b9bf625b3626f8765d44248927fb200906Dan Gohman 576af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 577ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng if (TimePassesIsEnabled) { 5785e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman NamedRegionTimer T("DAG Combining 1", GroupName); 57925cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands CurDAG->Combine(Unrestricted, *AA, Fast); 580ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } else { 58125cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands CurDAG->Combine(Unrestricted, *AA, Fast); 582ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } 5832300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 584417e11b9bf625b3626f8765d44248927fb200906Dan Gohman DOUT << "Optimized lowered selection DAG:\n"; 585f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DEBUG(CurDAG->dump()); 586f00e74f4d64385e6b2ee29887114e7c8abdf1f17Duncan Sands 5871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 5881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 5897cb07874dcadaa9a5082a80959cd15d44ba3a133Duncan Sands if (!DisableLegalizeTypes) { 590f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (ViewLegalizeTypesDAGs) CurDAG->viewGraph("legalize-types input for " + 591f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman BlockName); 592462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 59325cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands bool Changed; 594462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman if (TimePassesIsEnabled) { 595462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman NamedRegionTimer T("Type Legalization", GroupName); 59625cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = CurDAG->LegalizeTypes(); 597462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman } else { 59825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = CurDAG->LegalizeTypes(); 599462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman } 600462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 601462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman DOUT << "Type-legalized selection DAG:\n"; 602f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DEBUG(CurDAG->dump()); 603462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 60425cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands if (Changed) { 60525cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands if (ViewDAGCombineLT) 60625cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands CurDAG->viewGraph("dag-combine-lt input for " + BlockName); 60725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 60825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands // Run the DAG combiner in post-type-legalize mode. 60925cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands if (TimePassesIsEnabled) { 61025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands NamedRegionTimer T("DAG Combining after legalize types", GroupName); 61125cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands CurDAG->Combine(NoIllegalTypes, *AA, Fast); 61225cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands } else { 61325cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands CurDAG->Combine(NoIllegalTypes, *AA, Fast); 61425cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands } 61525cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 61625cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands DOUT << "Optimized type-legalized selection DAG:\n"; 61725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands DEBUG(CurDAG->dump()); 61825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands } 61970587ea813986bb0dbef71610091d496e28c22a6Chris Lattner } 620f00e74f4d64385e6b2ee29887114e7c8abdf1f17Duncan Sands 621f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (ViewLegalizeDAGs) CurDAG->viewGraph("legalize input for " + BlockName); 622462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 623ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng if (TimePassesIsEnabled) { 6245e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman NamedRegionTimer T("DAG Legalization", GroupName); 625b6862bbe34be4a832f709596f8dc971ab9895b06Duncan Sands CurDAG->Legalize(DisableLegalizeTypes); 626ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } else { 627b6862bbe34be4a832f709596f8dc971ab9895b06Duncan Sands CurDAG->Legalize(DisableLegalizeTypes); 628ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } 629f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 630832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Legalized selection DAG:\n"; 631f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DEBUG(CurDAG->dump()); 632f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 633f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (ViewDAGCombine2) CurDAG->viewGraph("dag-combine2 input for " + BlockName); 634462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 635af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 636ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng if (TimePassesIsEnabled) { 6375e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman NamedRegionTimer T("DAG Combining 2", GroupName); 63825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands CurDAG->Combine(NoIllegalOperations, *AA, Fast); 639ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } else { 64025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands CurDAG->Combine(NoIllegalOperations, *AA, Fast); 641ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } 6422300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 643417e11b9bf625b3626f8765d44248927fb200906Dan Gohman DOUT << "Optimized legalized selection DAG:\n"; 644f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DEBUG(CurDAG->dump()); 645417e11b9bf625b3626f8765d44248927fb200906Dan Gohman 646f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (ViewISelDAGs) CurDAG->viewGraph("isel input for " + BlockName); 647ead0d88ad7659dabd66cc3149af97d98256fca84Chris Lattner 648925a7e8ed6522f291b4ae559ccfa56db461016e3Dan Gohman if (!Fast && EnableValueProp) 649f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman ComputeLiveOutVRegInfo(); 650552c4a849422ad91fa9988255ae35aebbf3acf7bEvan Cheng 651a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 652a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 653ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng if (TimePassesIsEnabled) { 6545e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman NamedRegionTimer T("Instruction Selection", GroupName); 655f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman InstructionSelect(); 656ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } else { 657f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman InstructionSelect(); 658ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } 659db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng 660462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman DOUT << "Selected selection DAG:\n"; 661f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DEBUG(CurDAG->dump()); 662462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 663f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (ViewSchedDAGs) CurDAG->viewGraph("scheduler input for " + BlockName); 664462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 6655e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman // Schedule machine code. 6665e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman ScheduleDAG *Scheduler; 6675e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman if (TimePassesIsEnabled) { 6685e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman NamedRegionTimer T("Instruction Scheduling", GroupName); 669f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman Scheduler = Schedule(); 6705e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman } else { 671f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman Scheduler = Schedule(); 6725e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman } 6735e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman 674462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman if (ViewSUnitDAGs) Scheduler->viewGraph(); 675462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman 676db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng // Emit machine code to BB. This can change 'BB' to the last block being 677db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng // inserted into. 678ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng if (TimePassesIsEnabled) { 6795e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman NamedRegionTimer T("Instruction Creation", GroupName); 6805e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman BB = Scheduler->EmitSchedule(); 681ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } else { 6825e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman BB = Scheduler->EmitSchedule(); 6835e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman } 6845e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman 6855e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman // Free the scheduler state. 6865e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman if (TimePassesIsEnabled) { 6875e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman NamedRegionTimer T("Instruction Scheduling Cleanup", GroupName); 6885e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman delete Scheduler; 6895e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman } else { 6905e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman delete Scheduler; 691ebffb660a68384dd8b5e2ff36d68e94a3920611bEvan Cheng } 692db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng 693832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Selected machine code:\n"; 6941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 695f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 696f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 697d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohmanvoid SelectionDAGISel::SelectAllBasicBlocks(Function &Fn, MachineFunction &MF, 698dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman MachineModuleInfo *MMI, 699dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetInstrInfo &TII) { 700a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Initialize the Fast-ISel state, if needed. 701a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman FastISel *FastIS = 0; 702a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (EnableFastISel) 703a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman FastIS = TLI.createFastISel(*FuncInfo->MF, MMI, 704a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman FuncInfo->ValueMap, 705a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman FuncInfo->MBBMap, 706dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman FuncInfo->StaticAllocaMap 707dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 708dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman , FuncInfo->CatchInfoLost 709dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 710dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman ); 711a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman 712a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Iterate over all basic blocks in the function. 71339fd6e81b1b0de8b820155dc6a0dae226c109de6Evan Cheng for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) { 71439fd6e81b1b0de8b820155dc6a0dae226c109de6Evan Cheng BasicBlock *LLVMBB = &*I; 7157c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman BB = FuncInfo->MBBMap[LLVMBB]; 716f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 7173df24e667f04a7003342b534310919abc9c87418Dan Gohman BasicBlock::iterator const Begin = LLVMBB->begin(); 7183df24e667f04a7003342b534310919abc9c87418Dan Gohman BasicBlock::iterator const End = LLVMBB->end(); 7199f1185076d60153fd35feb3cadb1b4cd8debc0b6Evan Cheng BasicBlock::iterator BI = Begin; 7205edd361497f4c78a20fcbb75c6e7e94ff8046ed1Dan Gohman 7215edd361497f4c78a20fcbb75c6e7e94ff8046ed1Dan Gohman // Lower any arguments needed in this block if this is the entry block. 72233134c4a75558288d663267c8991f6bd37a530afDan Gohman bool SuppressFastISel = false; 72333134c4a75558288d663267c8991f6bd37a530afDan Gohman if (LLVMBB == &Fn.getEntryBlock()) { 7245edd361497f4c78a20fcbb75c6e7e94ff8046ed1Dan Gohman LowerArguments(LLVMBB); 725f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 72633134c4a75558288d663267c8991f6bd37a530afDan Gohman // If any of the arguments has the byval attribute, forgo 72733134c4a75558288d663267c8991f6bd37a530afDan Gohman // fast-isel in the entry block. 728a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (FastIS) { 72933134c4a75558288d663267c8991f6bd37a530afDan Gohman unsigned j = 1; 73033134c4a75558288d663267c8991f6bd37a530afDan Gohman for (Function::arg_iterator I = Fn.arg_begin(), E = Fn.arg_end(); 73133134c4a75558288d663267c8991f6bd37a530afDan Gohman I != E; ++I, ++j) 7320598866c052147c31b808391f58434ce3dbfb838Devang Patel if (Fn.paramHasAttr(j, Attribute::ByVal)) { 73377ca41e5c3f99ee8962b21a7d90bb251a594a65eDan Gohman if (EnableFastISelVerbose || EnableFastISelAbort) 73477ca41e5c3f99ee8962b21a7d90bb251a594a65eDan Gohman cerr << "FastISel skips entry block due to byval argument\n"; 73533134c4a75558288d663267c8991f6bd37a530afDan Gohman SuppressFastISel = true; 73633134c4a75558288d663267c8991f6bd37a530afDan Gohman break; 73733134c4a75558288d663267c8991f6bd37a530afDan Gohman } 73833134c4a75558288d663267c8991f6bd37a530afDan Gohman } 73933134c4a75558288d663267c8991f6bd37a530afDan Gohman } 74033134c4a75558288d663267c8991f6bd37a530afDan Gohman 741dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (MMI && BB->isLandingPad()) { 742dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // Add a label to mark the beginning of the landing pad. Deletion of the 743dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // landing pad can thus be detected via the MachineModuleInfo. 744dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned LabelID = MMI->addLandingPad(BB); 745dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 746dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetInstrDesc &II = TII.get(TargetInstrInfo::EH_LABEL); 747dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman BuildMI(BB, II).addImm(LabelID); 748dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 749dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // Mark exception register as live in. 750dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionAddressRegister(); 751dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (Reg) BB->addLiveIn(Reg); 752dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 753dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // Mark exception selector register as live in. 754dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman Reg = TLI.getExceptionSelectorRegister(); 755dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (Reg) BB->addLiveIn(Reg); 756dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 757dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // FIXME: Hack around an exception handling flaw (PR1508): the personality 758dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // function and list of typeids logically belong to the invoke (or, if you 759dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // like, the basic block containing the invoke), and need to be associated 760dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // with it in the dwarf exception handling tables. Currently however the 761dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // information is provided by an intrinsic (eh.selector) that can be moved 762dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // to unexpected places by the optimizers: if the unwind edge is critical, 763dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // then breaking it can result in the intrinsics being in the successor of 764dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // the landing pad, not the landing pad itself. This results in exceptions 765dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // not being caught because no typeids are associated with the invoke. 766dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // This may not be the only way things can go wrong, but it is the only way 767dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // we try to work around for the moment. 768dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman BranchInst *Br = dyn_cast<BranchInst>(LLVMBB->getTerminator()); 769dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 770dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (Br && Br->isUnconditional()) { // Critical edge? 771dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman BasicBlock::iterator I, E; 772dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman for (I = LLVMBB->begin(), E = --LLVMBB->end(); I != E; ++I) 773dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (isa<EHSelectorInst>(I)) 774dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 775dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 776dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (I == E) 777dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // No catch info found - try to extract some from the successor. 778dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman copyCatchInfo(Br->getSuccessor(0), LLVMBB, MMI, *FuncInfo); 779dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 780dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 781dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 782f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman // Before doing SelectionDAG ISel, see if FastISel has been requested. 783dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (FastIS && !SuppressFastISel) { 784a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Emit code for any incoming arguments. This must happen before 785a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // beginning FastISel on the entry block. 786a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (LLVMBB == &Fn.getEntryBlock()) { 787a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman CurDAG->setRoot(SDL->getControlRoot()); 788a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman CodeGenAndEmitDAG(); 789a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman SDL->clear(); 790a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman } 791241f464d24a6c22721607841069bbeb17b3f71e6Dan Gohman FastIS->startNewBlock(BB); 792a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Do FastISel on as many instructions as possible. 793a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman for (; BI != End; ++BI) { 794a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Just before the terminator instruction, insert instructions to 795a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // feed PHI nodes in successor blocks. 796a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (isa<TerminatorInst>(BI)) 797a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (!HandlePHINodesInSuccessorBlocksFast(LLVMBB, FastIS)) { 79877ca41e5c3f99ee8962b21a7d90bb251a594a65eDan Gohman if (EnableFastISelVerbose || EnableFastISelAbort) { 799a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman cerr << "FastISel miss: "; 80077ca41e5c3f99ee8962b21a7d90bb251a594a65eDan Gohman BI->dump(); 80177ca41e5c3f99ee8962b21a7d90bb251a594a65eDan Gohman } 802a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (EnableFastISelAbort) 803a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman assert(0 && "FastISel didn't handle a PHI in a successor"); 804a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman break; 805a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman } 80633134c4a75558288d663267c8991f6bd37a530afDan Gohman 807a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // First try normal tablegen-generated "fast" selection. 808a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (FastIS->SelectInstruction(BI)) 809a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman continue; 810a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman 811a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Next, try calling the target to attempt to handle the instruction. 812a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (FastIS->TargetSelectInstruction(BI)) 813a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman continue; 814f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 815a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Then handle certain instructions as single-LLVM-Instruction blocks. 816a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (isa<CallInst>(BI)) { 817a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (EnableFastISelVerbose || EnableFastISelAbort) { 818a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman cerr << "FastISel missed call: "; 819a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman BI->dump(); 820f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 821f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 822a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (BI->getType() != Type::VoidTy) { 823a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman unsigned &R = FuncInfo->ValueMap[BI]; 824a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (!R) 825a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman R = FuncInfo->CreateRegForValue(BI); 826f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 827a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman 828a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman SelectBasicBlock(LLVMBB, BI, next(BI)); 829241f464d24a6c22721607841069bbeb17b3f71e6Dan Gohman // If the instruction was codegen'd with multiple blocks, 830241f464d24a6c22721607841069bbeb17b3f71e6Dan Gohman // inform the FastISel object where to resume inserting. 831241f464d24a6c22721607841069bbeb17b3f71e6Dan Gohman FastIS->setCurrentBlock(BB); 832a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman continue; 833f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 834a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman 835a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // Otherwise, give up on FastISel for the rest of the block. 836a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // For now, be a little lenient about non-branch terminators. 837a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (!isa<TerminatorInst>(BI) || isa<BranchInst>(BI)) { 838a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (EnableFastISelVerbose || EnableFastISelAbort) { 839a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman cerr << "FastISel miss: "; 840a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman BI->dump(); 841a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman } 842a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman if (EnableFastISelAbort) 843a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // The "fast" selector couldn't handle something and bailed. 844a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman // For the purpose of debugging, just abort. 845a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman assert(0 && "FastISel didn't select the entire block"); 846a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman } 847a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman break; 848f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 849f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 850f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 851d2ff647964ed242e67ac12f7d21a58c864309d95Dan Gohman // Run SelectionDAG instruction selection on the remainder of the block 852d2ff647964ed242e67ac12f7d21a58c864309d95Dan Gohman // not handled by FastISel. If FastISel is not run, this is the entire 8533df24e667f04a7003342b534310919abc9c87418Dan Gohman // block. 8549f1185076d60153fd35feb3cadb1b4cd8debc0b6Evan Cheng if (BI != End) 8559f1185076d60153fd35feb3cadb1b4cd8debc0b6Evan Cheng SelectBasicBlock(LLVMBB, BI, End); 856381cb07544a2bc119e39969d7d508a6247773e1cEvan Cheng 8577c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman FinishBasicBlock(); 85839fd6e81b1b0de8b820155dc6a0dae226c109de6Evan Cheng } 859a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman 860a43abd102f123f6d3bd9ad92045f8119e3fb6153Dan Gohman delete FastIS; 8610e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman} 8620e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman 863fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanvoid 8647c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan GohmanSelectionDAGISel::FinishBasicBlock() { 8651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 866f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DOUT << "Target-post-processed machine code:\n"; 867f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman DEBUG(BB->dump()); 8684198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 8694198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Total amount of phi nodes to update: " 8707c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman << SDL->PHINodesToUpdate.size() << "\n"; 8717c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman DEBUG(for (unsigned i = 0, e = SDL->PHINodesToUpdate.size(); i != e; ++i) 8727c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman DOUT << "Node " << i << " : (" << SDL->PHINodesToUpdate[i].first 8737c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman << ", " << SDL->PHINodesToUpdate[i].second << ")\n";); 874f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 875a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 8761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 8777c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (SDL->SwitchCases.empty() && 8787c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->JTCases.empty() && 8797c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->BitTestCases.empty()) { 8807c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned i = 0, e = SDL->PHINodesToUpdate.size(); i != e; ++i) { 8817c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineInstr *PHI = SDL->PHINodesToUpdate[i].first; 882f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 883f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 8847c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[i].second, 8859ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 8869ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BB)); 887f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 8887c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->PHINodesToUpdate.clear(); 889f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 8901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 8914198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 8927c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned i = 0, e = SDL->BitTestCases.size(); i != e; ++i) { 8934198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Lower header first, if it wasn't already lowered 8947c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (!SDL->BitTestCases[i].Emitted) { 8954198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Set the current basic block to the mbb we wish to insert the code into 8967c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman BB = SDL->BitTestCases[i].Parent; 8977c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->setCurrentBasicBlock(BB); 8984198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Emit the code 8997c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->visitBitTestHeader(SDL->BitTestCases[i]); 9007c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman CurDAG->setRoot(SDL->getRoot()); 901f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CodeGenAndEmitDAG(); 9027c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->clear(); 9034198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9044198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 9057c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned j = 0, ej = SDL->BitTestCases[i].Cases.size(); j != ej; ++j) { 9064198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Set the current basic block to the mbb we wish to insert the code into 9077c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman BB = SDL->BitTestCases[i].Cases[j].ThisBB; 9087c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->setCurrentBasicBlock(BB); 9094198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Emit the code 9104198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (j+1 != ej) 9117c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->visitBitTestCase(SDL->BitTestCases[i].Cases[j+1].ThisBB, 9127c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->BitTestCases[i].Reg, 9137c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->BitTestCases[i].Cases[j]); 9144198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov else 9157c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->visitBitTestCase(SDL->BitTestCases[i].Default, 9167c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->BitTestCases[i].Reg, 9177c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->BitTestCases[i].Cases[j]); 9184198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 9194198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 9207c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman CurDAG->setRoot(SDL->getRoot()); 921f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CodeGenAndEmitDAG(); 9227c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->clear(); 9234198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9244198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 9254198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Update PHI Nodes 9267c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned pi = 0, pe = SDL->PHINodesToUpdate.size(); pi != pe; ++pi) { 9277c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineInstr *PHI = SDL->PHINodesToUpdate[pi].first; 9284198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock *PHIBB = PHI->getParent(); 9294198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov assert(PHI->getOpcode() == TargetInstrInfo::PHI && 9304198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov "This is not a machine PHI node that we are updating!"); 9314198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // This is "default" BB. We have two jumps to it. From "header" BB and 9324198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // from last "case" BB. 9337c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (PHIBB == SDL->BitTestCases[i].Default) { 9347c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[pi].second, 9359ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 9367c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateMBB(SDL->BitTestCases[i].Parent)); 9377c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[pi].second, 9389ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 9397c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateMBB(SDL->BitTestCases[i].Cases. 9409ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner back().ThisBB)); 9414198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9424198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // One of "cases" BB. 9437c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned j = 0, ej = SDL->BitTestCases[i].Cases.size(); 9447c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman j != ej; ++j) { 9457c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineBasicBlock* cBB = SDL->BitTestCases[i].Cases[j].ThisBB; 9464198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (cBB->succ_end() != 9474198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov std::find(cBB->succ_begin(),cBB->succ_end(), PHIBB)) { 9487c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[pi].second, 9499ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 9509ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(cBB)); 9514198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9524198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9534198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9544198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9557c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->BitTestCases.clear(); 9564198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 9579453eea49bca1c3904047db495855c93e001d1cdNate Begeman // If the JumpTable record is filled in, then we need to emit a jump table. 9589453eea49bca1c3904047db495855c93e001d1cdNate Begeman // Updating the PHI nodes is tricky in this case, since we need to determine 9599453eea49bca1c3904047db495855c93e001d1cdNate Begeman // whether the PHI is a successor of the range check MBB or the jump table MBB 9607c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned i = 0, e = SDL->JTCases.size(); i != e; ++i) { 9613a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Lower header first, if it wasn't already lowered 9627c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (!SDL->JTCases[i].first.Emitted) { 9633a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Set the current basic block to the mbb we wish to insert the code into 9647c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman BB = SDL->JTCases[i].first.HeaderBB; 9657c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->setCurrentBasicBlock(BB); 9663a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Emit the code 9677c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->visitJumpTableHeader(SDL->JTCases[i].second, SDL->JTCases[i].first); 9687c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman CurDAG->setRoot(SDL->getRoot()); 969f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CodeGenAndEmitDAG(); 9707c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->clear(); 9714198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 9723a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 97337efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 9747c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman BB = SDL->JTCases[i].second.MBB; 9757c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->setCurrentBasicBlock(BB); 97637efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code 9777c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->visitJumpTable(SDL->JTCases[i].second); 9787c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman CurDAG->setRoot(SDL->getRoot()); 979f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CodeGenAndEmitDAG(); 9807c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->clear(); 9813a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 98237efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update PHI Nodes 9837c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned pi = 0, pe = SDL->PHINodesToUpdate.size(); pi != pe; ++pi) { 9847c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineInstr *PHI = SDL->PHINodesToUpdate[pi].first; 98537efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 98637efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 98737efe6764568a3829fee26aba532283131d1a104Nate Begeman "This is not a machine PHI node that we are updating!"); 9884198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // "default" BB. We can go there only from header BB. 9897c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (PHIBB == SDL->JTCases[i].second.Default) { 9907c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[pi].second, 9919ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 9927c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateMBB(SDL->JTCases[i].first.HeaderBB)); 993f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 9944198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // JT BB. Just iterate over successors here 995f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (BB->succ_end() != std::find(BB->succ_begin(),BB->succ_end(), PHIBB)) { 9967c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[pi].second, 9979ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 9989ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BB)); 99937efe6764568a3829fee26aba532283131d1a104Nate Begeman } 100037efe6764568a3829fee26aba532283131d1a104Nate Begeman } 100137efe6764568a3829fee26aba532283131d1a104Nate Begeman } 10027c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->JTCases.clear(); 100337efe6764568a3829fee26aba532283131d1a104Nate Begeman 1004b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // If the switch block involved a branch to one of the actual successors, we 1005b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // need to update PHI nodes in that block. 10067c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned i = 0, e = SDL->PHINodesToUpdate.size(); i != e; ++i) { 10077c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineInstr *PHI = SDL->PHINodesToUpdate[i].first; 1008b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 1009b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner "This is not a machine PHI node that we are updating!"); 1010b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner if (BB->isSuccessor(PHI->getParent())) { 10117c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman PHI->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[i].second, 10129ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 10139ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BB)); 1014b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 1015b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 1016b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner 1017f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 1018f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 10197c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman for (unsigned i = 0, e = SDL->SwitchCases.size(); i != e; ++i) { 1020f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 10217c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman BB = SDL->SwitchCases[i].ThisBB; 10227c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->setCurrentBasicBlock(BB); 1023d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 1024f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 10257c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->visitSwitchCase(SDL->SwitchCases[i]); 10267c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman CurDAG->setRoot(SDL->getRoot()); 1027f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CodeGenAndEmitDAG(); 10287c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->clear(); 1029d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 1030d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Handle any PHI nodes in successors of this chunk, as if we were coming 1031d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // from the original BB before switch expansion. Note that PHI nodes can 1032d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // occur multiple times in PHINodesToUpdate. We have to be very careful to 1033d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // handle them the right number of times. 10347c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman while ((BB = SDL->SwitchCases[i].TrueBB)) { // Handle LHS and RHS. 1035d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (MachineBasicBlock::iterator Phi = BB->begin(); 1036d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi != BB->end() && Phi->getOpcode() == TargetInstrInfo::PHI; ++Phi){ 1037d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // This value for this PHI node is recorded in PHINodesToUpdate, get it. 1038d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned pn = 0; ; ++pn) { 10397c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman assert(pn != SDL->PHINodesToUpdate.size() && 10407c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman "Didn't find PHI entry!"); 10417c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (SDL->PHINodesToUpdate[pn].first == Phi) { 10427c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman Phi->addOperand(MachineOperand::CreateReg(SDL->PHINodesToUpdate[pn]. 10439ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner second, false)); 10447c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman Phi->addOperand(MachineOperand::CreateMBB(SDL->SwitchCases[i].ThisBB)); 1045d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner break; 1046d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 1047d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 1048f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1049d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 1050d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Don't process RHS if same block as LHS. 10517c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman if (BB == SDL->SwitchCases[i].FalseBB) 10527c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->SwitchCases[i].FalseBB = 0; 1053d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 1054d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // If we haven't handled the RHS, do so now. Otherwise, we're done. 10557c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->SwitchCases[i].TrueBB = SDL->SwitchCases[i].FalseBB; 10567c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->SwitchCases[i].FalseBB = 0; 1057f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 10587c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman assert(SDL->SwitchCases[i].TrueBB == 0 && SDL->SwitchCases[i].FalseBB == 0); 1059a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 10607c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->SwitchCases.clear(); 10617c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman 10627c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman SDL->PHINodesToUpdate.clear(); 10631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1064a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 106513ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 10665e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman/// Schedule - Pick a safe ordering for instructions for each 1067a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 10685e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman/// 1069f350b277f32d7d47f86c0e54f4aec4d470500618Dan GohmanScheduleDAG *SelectionDAGISel::Schedule() { 1070eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterScheduler::FunctionPassCtor Ctor = RegisterScheduler::getDefault(); 107113ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 107213ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 1073eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = ISHeuristic; 10749373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey RegisterScheduler::setDefault(Ctor); 10754ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 107613ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 10779b75b373756288cd39489da7994207f50b31ee40Dan Gohman TargetMachine &TM = getTargetLowering().getTargetMachine(); 10789b75b373756288cd39489da7994207f50b31ee40Dan Gohman ScheduleDAG *Scheduler = Ctor(this, CurDAG, &TM, BB, Fast); 10795e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman Scheduler->Run(); 10803e1a7aef17575d9c7058a035449d57e3c7295ed0Dan Gohman 10815e84368b26415b3bb7f3f8d9cff3e05938dd82d0Dan Gohman return Scheduler; 1082a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 10830e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 108403fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 10859ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim LaskeyHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 10869ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey return new HazardRecognizer(); 10879ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey} 10889ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 1089755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 1090755480681c795d585c73556c028b6143c46bda86Chris Lattner// Helper functions used by the generated instruction selector. 1091755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 1092755480681c795d585c73556c028b6143c46bda86Chris Lattner// Calls to these methods are generated by tblgen. 1093755480681c795d585c73556c028b6143c46bda86Chris Lattner 1094755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckAndMask - The isel is trying to match something like (and X, 255). If 1095755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 1096755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an AND, and DesiredMaskS is the value 1097755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 1098475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanbool SelectionDAGISel::CheckAndMask(SDValue LHS, ConstantSDNode *RHS, 1099dc9b3d0bb5ed3a3f59cad61e264f0ec43c946459Dan Gohman int64_t DesiredMaskS) const { 11002e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman const APInt &ActualMask = RHS->getAPIntValue(); 11012e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman const APInt &DesiredMask = APInt(LHS.getValueSizeInBits(), DesiredMaskS); 1102755480681c795d585c73556c028b6143c46bda86Chris Lattner 1103755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 1104755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 1105755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 1106755480681c795d585c73556c028b6143c46bda86Chris Lattner 1107755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 11082e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman if (ActualMask.intersects(~DesiredMask)) 1109755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 1110755480681c795d585c73556c028b6143c46bda86Chris Lattner 1111755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 1112755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 11132e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman APInt NeededMask = DesiredMask & ~ActualMask; 1114ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman if (CurDAG->MaskedValueIsZero(LHS, NeededMask)) 1115755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 1116755480681c795d585c73556c028b6143c46bda86Chris Lattner 1117755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 1118755480681c795d585c73556c028b6143c46bda86Chris Lattner 1119755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 1120755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 1121755480681c795d585c73556c028b6143c46bda86Chris Lattner} 1122755480681c795d585c73556c028b6143c46bda86Chris Lattner 1123755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckOrMask - The isel is trying to match something like (or X, 255). If 1124755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 1125755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an OR, and DesiredMaskS is the value 1126755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 1127475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanbool SelectionDAGISel::CheckOrMask(SDValue LHS, ConstantSDNode *RHS, 11282e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman int64_t DesiredMaskS) const { 11292e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman const APInt &ActualMask = RHS->getAPIntValue(); 11302e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman const APInt &DesiredMask = APInt(LHS.getValueSizeInBits(), DesiredMaskS); 1131755480681c795d585c73556c028b6143c46bda86Chris Lattner 1132755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 1133755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 1134755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 1135755480681c795d585c73556c028b6143c46bda86Chris Lattner 1136755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 11372e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman if (ActualMask.intersects(~DesiredMask)) 1138755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 1139755480681c795d585c73556c028b6143c46bda86Chris Lattner 1140755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 1141755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 11422e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman APInt NeededMask = DesiredMask & ~ActualMask; 1143755480681c795d585c73556c028b6143c46bda86Chris Lattner 11442e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman APInt KnownZero, KnownOne; 1145ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman CurDAG->ComputeMaskedBits(LHS, NeededMask, KnownZero, KnownOne); 1146755480681c795d585c73556c028b6143c46bda86Chris Lattner 1147755480681c795d585c73556c028b6143c46bda86Chris Lattner // If all the missing bits in the or are already known to be set, match! 1148755480681c795d585c73556c028b6143c46bda86Chris Lattner if ((NeededMask & KnownOne) == NeededMask) 1149755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 1150755480681c795d585c73556c028b6143c46bda86Chris Lattner 1151755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 1152755480681c795d585c73556c028b6143c46bda86Chris Lattner 1153755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 1154755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 1155755480681c795d585c73556c028b6143c46bda86Chris Lattner} 1156755480681c795d585c73556c028b6143c46bda86Chris Lattner 11579ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 11580e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 11590e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 11600e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 1161f350b277f32d7d47f86c0e54f4aec4d470500618Dan GohmanSelectInlineAsmMemoryOperands(std::vector<SDValue> &Ops) { 1162475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::vector<SDValue> InOps; 11630e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 11640e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 11650e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 11660e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 11670e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 11680e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 11690e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 11700e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 11710e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 11720e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 1173f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned Flags = cast<ConstantSDNode>(InOps[i])->getZExtValue(); 117486b49f8e2de796cb46c7c8b6a4c4900533fd53f4Dale Johannesen if ((Flags & 7) != 4 /*MEM*/) { 11750e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 11760e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 11770e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 11780e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 11790e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 11800e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 1181475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::vector<SDValue> SelOps; 1182f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps)) { 1183832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Could not match memory address. Inline asm failure!\n"; 11840e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 11850e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 11860e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 11870e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 1188f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman MVT IntPtrTy = CurDAG->getTargetLoweringInfo().getPointerTy(); 118986b49f8e2de796cb46c7c8b6a4c4900533fd53f4Dale Johannesen Ops.push_back(CurDAG->getTargetConstant(4/*MEM*/ | (SelOps.size()<< 3), 1190f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman IntPtrTy)); 11910e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 11920e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 11930e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 11940e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 11950e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 11960e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 11970e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 11980e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 11990e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 1200794fd75c67a2cdc128d67342c6d88a504d186896Devang Patel 12011997473cf72957d0e70322e2fe6fe2ab141c58a6Devang Patelchar SelectionDAGISel::ID = 0; 1202