llvm.org GIT mirror llvm / d659d34
[C++11] Add 'override' keyword to virtual methods that override their base class. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@203339 91177308-0d34-0410-b5e6-96231b3b80d8 Craig Topper 6 years ago
19 changed file(s) with 143 addition(s) and 142 deletion(s). Raw diff Collapse all Expand all
8080 delete ResourcesModel;
8181 }
8282
83 bool isBottomUp() const { return false; }
83 bool isBottomUp() const override { return false; }
8484
85 void initNodes(std::vector &sunits);
85 void initNodes(std::vector &sunits) override;
8686
87 void addNode(const SUnit *SU) {
87 void addNode(const SUnit *SU) override {
8888 NumNodesSolelyBlocking.resize(SUnits->size(), 0);
8989 }
9090
91 void updateNode(const SUnit *SU) {}
91 void updateNode(const SUnit *SU) override {}
9292
93 void releaseState() {
93 void releaseState() override {
9494 SUnits = 0;
9595 }
9696
115115 signed regPressureDelta(SUnit *SU, bool RawPressure = false);
116116 signed rawRegPressureDelta (SUnit *SU, unsigned RCId);
117117
118 bool empty() const { return Queue.empty(); }
118 bool empty() const override { return Queue.empty(); }
119119
120 virtual void push(SUnit *U);
120 void push(SUnit *U) override;
121121
122 virtual SUnit *pop();
122 SUnit *pop() override;
123123
124 virtual void remove(SUnit *SU);
124 void remove(SUnit *SU) override;
125125
126 virtual void dump(ScheduleDAG* DAG) const;
126 void dump(ScheduleDAG* DAG) const override;
127127
128128 /// scheduledNode - Main resource tracking point.
129 void scheduledNode(SUnit *Node);
129 void scheduledNode(SUnit *Node) override;
130130 bool isResourceAvailable(SUnit *SU);
131131 void reserveResources(SUnit *SU);
132132
5959 return TM.getTargetLowering();
6060 }
6161
62 virtual void getAnalysisUsage(AnalysisUsage &AU) const;
63
64 virtual bool runOnMachineFunction(MachineFunction &MF);
62 void getAnalysisUsage(AnalysisUsage &AU) const override;
63
64 bool runOnMachineFunction(MachineFunction &MF) override;
6565
6666 virtual void EmitFunctionEntryCode() {}
6767
3535
3636 protected:
3737 /// LexToken - Read the next token and return its code.
38 virtual AsmToken LexToken();
38 AsmToken LexToken() override;
3939
4040 public:
4141 AsmLexer(const MCAsmInfo &MAI);
4343
4444 void setBuffer(const MemoryBuffer *buf, const char *ptr = NULL);
4545
46 virtual StringRef LexUntilEndOfStatement();
46 StringRef LexUntilEndOfStatement() override;
4747 StringRef LexUntilEndOfLine();
4848
49 virtual const AsmToken peekTok(bool ShouldSkipSpace = true);
49 const AsmToken peekTok(bool ShouldSkipSpace = true) override;
5050
5151 bool isAtStartOfComment(char Char);
5252 bool isAtStatementSeparator(const char *Ptr);
3636
3737 public:
3838 APByteStreamer(AsmPrinter &Asm) : AP(Asm) {}
39 void EmitInt8(uint8_t Byte, const Twine &Comment) {
39 void EmitInt8(uint8_t Byte, const Twine &Comment) override {
4040 AP.OutStreamer.AddComment(Comment);
4141 AP.EmitInt8(Byte);
4242 }
43 void EmitSLEB128(uint64_t DWord, const Twine &Comment) {
43 void EmitSLEB128(uint64_t DWord, const Twine &Comment) override {
4444 AP.OutStreamer.AddComment(Comment);
4545 AP.EmitSLEB128(DWord);
4646 }
47 void EmitULEB128(uint64_t DWord, const Twine &Comment) {
47 void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
4848 AP.OutStreamer.AddComment(Comment);
4949 AP.EmitULEB128(DWord);
5050 }
5555 DIEHash &Hash;
5656 public:
5757 HashingByteStreamer(DIEHash &H) : Hash(H) {}
58 void EmitInt8(uint8_t Byte, const Twine &Comment) {
58 void EmitInt8(uint8_t Byte, const Twine &Comment) override {
5959 Hash.update(Byte);
6060 }
61 void EmitSLEB128(uint64_t DWord, const Twine &Comment) {
61 void EmitSLEB128(uint64_t DWord, const Twine &Comment) override {
6262 Hash.addSLEB128(DWord);
6363 }
64 void EmitULEB128(uint64_t DWord, const Twine &Comment) {
64 void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
6565 Hash.addULEB128(DWord);
6666 }
6767 };
264264
265265 /// EmitValue - Emit integer of appropriate size.
266266 ///
267 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
267 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
268268
269269 uint64_t getValue() const { return Integer; }
270270
271271 /// SizeOf - Determine size of integer value in bytes.
272272 ///
273 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
273 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
274274
275275 // Implement isa/cast/dyncast.
276276 static bool classof(const DIEValue *I) { return I->getType() == isInteger; }
277277
278278 #ifndef NDEBUG
279 virtual void print(raw_ostream &O) const;
279 void print(raw_ostream &O) const override;
280280 #endif
281281 };
282282
291291
292292 /// EmitValue - Emit expression value.
293293 ///
294 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
294 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
295295
296296 /// getValue - Get MCExpr.
297297 ///
299299
300300 /// SizeOf - Determine size of expression value in bytes.
301301 ///
302 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
302 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
303303
304304 // Implement isa/cast/dyncast.
305305 static bool classof(const DIEValue *E) { return E->getType() == isExpr; }
306306
307307 #ifndef NDEBUG
308 virtual void print(raw_ostream &O) const;
308 void print(raw_ostream &O) const override;
309309 #endif
310310 };
311311
320320
321321 /// EmitValue - Emit label value.
322322 ///
323 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
323 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
324324
325325 /// getValue - Get MCSymbol.
326326 ///
328328
329329 /// SizeOf - Determine size of label value in bytes.
330330 ///
331 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
331 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
332332
333333 // Implement isa/cast/dyncast.
334334 static bool classof(const DIEValue *L) { return L->getType() == isLabel; }
335335
336336 #ifndef NDEBUG
337 virtual void print(raw_ostream &O) const;
337 void print(raw_ostream &O) const override;
338338 #endif
339339 };
340340
351351
352352 /// EmitValue - Emit delta value.
353353 ///
354 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
354 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
355355
356356 /// SizeOf - Determine size of delta value in bytes.
357357 ///
358 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
358 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
359359
360360 // Implement isa/cast/dyncast.
361361 static bool classof(const DIEValue *D) { return D->getType() == isDelta; }
362362
363363 #ifndef NDEBUG
364 virtual void print(raw_ostream &O) const;
364 void print(raw_ostream &O) const override;
365365 #endif
366366 };
367367
381381
382382 /// EmitValue - Emit delta value.
383383 ///
384 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
384 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
385385
386386 /// SizeOf - Determine size of delta value in bytes.
387387 ///
388 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
388 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
389389
390390 // Implement isa/cast/dyncast.
391391 static bool classof(const DIEValue *D) { return D->getType() == isString; }
392392
393393 #ifndef NDEBUG
394 virtual void print(raw_ostream &O) const;
394 void print(raw_ostream &O) const override;
395395 #endif
396396 };
397397
411411
412412 /// EmitValue - Emit debug information entry offset.
413413 ///
414 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
414 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
415415
416416 /// SizeOf - Determine size of debug information entry in bytes.
417417 ///
418 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const {
418 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override {
419419 return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP)
420420 : sizeof(int32_t);
421421 }
427427 static bool classof(const DIEValue *E) { return E->getType() == isEntry; }
428428
429429 #ifndef NDEBUG
430 virtual void print(raw_ostream &O) const;
430 void print(raw_ostream &O) const override;
431431 #endif
432432 };
433433
441441 : DIEValue(isTypeSignature), Unit(Unit) {}
442442
443443 /// \brief Emit type unit signature.
444 virtual void EmitValue(AsmPrinter *Asm, dwarf::Form Form) const;
444 void EmitValue(AsmPrinter *Asm, dwarf::Form Form) const override;
445445
446446 /// Returns size of a ref_sig8 entry.
447 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const {
447 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override {
448448 assert(Form == dwarf::DW_FORM_ref_sig8);
449449 return 8;
450450 }
454454 return E->getType() == isTypeSignature;
455455 }
456456 #ifndef NDEBUG
457 virtual void print(raw_ostream &O) const;
457 void print(raw_ostream &O) const override;
458458 void dump() const;
459459 #endif
460460 };
488488
489489 /// EmitValue - Emit location data.
490490 ///
491 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
491 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
492492
493493 /// SizeOf - Determine size of location data in bytes.
494494 ///
495 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
495 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
496496
497497 // Implement isa/cast/dyncast.
498498 static bool classof(const DIEValue *E) { return E->getType() == isLoc; }
499499
500500 #ifndef NDEBUG
501 virtual void print(raw_ostream &O) const;
501 void print(raw_ostream &O) const override;
502502 #endif
503503 };
504504
528528
529529 /// EmitValue - Emit location data.
530530 ///
531 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
531 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
532532
533533 /// SizeOf - Determine size of location data in bytes.
534534 ///
535 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
535 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
536536
537537 // Implement isa/cast/dyncast.
538538 static bool classof(const DIEValue *E) { return E->getType() == isBlock; }
539539
540540 #ifndef NDEBUG
541 virtual void print(raw_ostream &O) const;
541 void print(raw_ostream &O) const override;
542542 #endif
543543 };
544544
558558
559559 /// EmitValue - Emit location data.
560560 ///
561 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const;
561 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override;
562562
563563 /// SizeOf - Determine size of location data in bytes.
564564 ///
565 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const;
565 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override;
566566
567567 // Implement isa/cast/dyncast.
568568 static bool classof(const DIEValue *E) { return E->getType() == isLocList; }
569569
570570 #ifndef NDEBUG
571 virtual void print(raw_ostream &O) const;
571 void print(raw_ostream &O) const override;
572572 #endif
573573 };
574574
701701 void beginModule();
702702
703703 /// \brief Emit all Dwarf sections that should come after the content.
704 void endModule();
704 void endModule() override;
705705
706706 /// \brief Gather pre-function debug information.
707 void beginFunction(const MachineFunction *MF);
707 void beginFunction(const MachineFunction *MF) override;
708708
709709 /// \brief Gather and emit post-function debug information.
710 void endFunction(const MachineFunction *MF);
710 void endFunction(const MachineFunction *MF) override;
711711
712712 /// \brief Process beginning of an instruction.
713 void beginInstruction(const MachineInstr *MI);
713 void beginInstruction(const MachineInstr *MI) override;
714714
715715 /// \brief Process end of an instruction.
716 void endInstruction();
716 void endInstruction() override;
717717
718718 /// \brief Add a DIE to the set of types that we're going to pull into
719719 /// type units.
725725
726726 /// \brief For symbols that have a size designated (e.g. common symbols),
727727 /// this tracks that size.
728 void setSymbolSize(const MCSymbol *Sym, uint64_t Size) {
728 void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
729729 SymSize[Sym] = Size;
730730 }
731731
129129
130130 /// endModule - Emit all exception information that should come after the
131131 /// content.
132 virtual void endModule();
133
134 /// beginFunction - Gather pre-function exception information. Assumes being
135 /// emitted immediately after the function entry point.
136 virtual void beginFunction(const MachineFunction *MF);
137
138 /// endFunction - Gather and emit post-function exception information.
139 virtual void endFunction(const MachineFunction *);
132 void endModule() override;
133
134 /// beginFunction - Gather pre-function exception information. Assumes being
135 /// emitted immediately after the function entry point.
136 void beginFunction(const MachineFunction *MF) override;
137
138 /// endFunction - Gather and emit post-function exception information.
139 void endFunction(const MachineFunction *) override;
140140
141141 // We don't need these.
142 virtual void setSymbolSize(const MCSymbol *Sym, uint64_t Size) {}
143 virtual void beginInstruction(const MachineInstr *MI) {}
144 virtual void endInstruction() {}
142 void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {}
143 void beginInstruction(const MachineInstr *MI) override {}
144 void endInstruction() override {}
145145 };
146146
147147 class DwarfCFIException : public DwarfException {
168168
169169 /// endModule - Emit all exception information that should come after the
170170 /// content.
171 virtual void endModule();
172
173 /// beginFunction - Gather pre-function exception information. Assumes being
174 /// emitted immediately after the function entry point.
175 virtual void beginFunction(const MachineFunction *MF);
176
177 /// endFunction - Gather and emit post-function exception information.
178 virtual void endFunction(const MachineFunction *);
171 void endModule() override;
172
173 /// beginFunction - Gather pre-function exception information. Assumes being
174 /// emitted immediately after the function entry point.
175 void beginFunction(const MachineFunction *MF) override;
176
177 /// endFunction - Gather and emit post-function exception information.
178 void endFunction(const MachineFunction *) override;
179179 };
180180
181181 class ARMException : public DwarfException {
182 void EmitTypeInfos(unsigned TTypeEncoding);
182 void EmitTypeInfos(unsigned TTypeEncoding) override;
183183 ARMTargetStreamer &getTargetStreamer();
184184
185185 /// shouldEmitCFI - Per-function flag to indicate if frame CFI info
195195
196196 /// endModule - Emit all exception information that should come after the
197197 /// content.
198 virtual void endModule();
199
200 /// beginFunction - Gather pre-function exception information. Assumes being
201 /// emitted immediately after the function entry point.
202 virtual void beginFunction(const MachineFunction *MF);
203
204 /// endFunction - Gather and emit post-function exception information.
205 virtual void endFunction(const MachineFunction *);
198 void endModule() override;
199
200 /// beginFunction - Gather pre-function exception information. Assumes being
201 /// emitted immediately after the function entry point.
202 void beginFunction(const MachineFunction *MF) override;
203
204 /// endFunction - Gather and emit post-function exception information.
205 void endFunction(const MachineFunction *) override;
206206 };
207207
208208 class Win64Exception : public DwarfException {
227227
228228 /// endModule - Emit all exception information that should come after the
229229 /// content.
230 virtual void endModule();
231
232 /// beginFunction - Gather pre-function exception information. Assumes being
233 /// emitted immediately after the function entry point.
234 virtual void beginFunction(const MachineFunction *MF);
235
236 /// endFunction - Gather and emit post-function exception information.
237 virtual void endFunction(const MachineFunction *);
230 void endModule() override;
231
232 /// beginFunction - Gather pre-function exception information. Assumes being
233 /// emitted immediately after the function entry point.
234 void beginFunction(const MachineFunction *MF) override;
235
236 /// endFunction - Gather and emit post-function exception information.
237 void endFunction(const MachineFunction *) override;
238238 };
239239
240240 } // End of namespace llvm
3434
3535 class ErlangGCPrinter : public GCMetadataPrinter {
3636 public:
37 void beginAssembly(AsmPrinter &AP);
38 void finishAssembly(AsmPrinter &AP);
37 void beginAssembly(AsmPrinter &AP) override;
38 void finishAssembly(AsmPrinter &AP) override;
3939 };
4040
4141 }
3232
3333 class OcamlGCMetadataPrinter : public GCMetadataPrinter {
3434 public:
35 void beginAssembly(AsmPrinter &AP);
36 void finishAssembly(AsmPrinter &AP);
35 void beginAssembly(AsmPrinter &AP) override;
36 void finishAssembly(AsmPrinter &AP) override;
3737 };
3838
3939 }
121121 free(I->second);
122122 }
123123
124 virtual void setSymbolSize(const llvm::MCSymbol *, uint64_t) {}
124 void setSymbolSize(const llvm::MCSymbol *, uint64_t) override {}
125125
126126 /// \brief Emit the COFF section that holds the line table information.
127 virtual void endModule();
127 void endModule() override;
128128
129129 /// \brief Gather pre-function debug information.
130 virtual void beginFunction(const MachineFunction *MF);
130 void beginFunction(const MachineFunction *MF) override;
131131
132132 /// \brief Gather post-function debug information.
133 virtual void endFunction(const MachineFunction *);
133 void endFunction(const MachineFunction *) override;
134134
135135 /// \brief Process beginning of an instruction.
136 virtual void beginInstruction(const MachineInstr *MI);
136 void beginInstruction(const MachineInstr *MI) override;
137137
138138 /// \brief Process end of an instruction.
139 virtual void endInstruction() {}
139 void endInstruction() override {}
140140 };
141141 } // End of namespace llvm
142142
408408 explicit WorkListRemover(DAGCombiner &dc)
409409 : SelectionDAG::DAGUpdateListener(dc.getDAG()), DC(dc) {}
410410
411 virtual void NodeDeleted(SDNode *N, SDNode *E) {
411 void NodeDeleted(SDNode *N, SDNode *E) override {
412412 DC.removeFromWorkList(N);
413413 }
414414 };
151151
152152 public:
153153 // DAGUpdateListener implementation.
154 virtual void NodeDeleted(SDNode *N, SDNode *E) {
154 void NodeDeleted(SDNode *N, SDNode *E) override {
155155 ForgetNode(N);
156156 }
157 virtual void NodeUpdated(SDNode *N) {}
157 void NodeUpdated(SDNode *N) override {}
158158
159159 // Node replacement helpers
160160 void ReplacedNode(SDNode *N) {
633633 : SelectionDAG::DAGUpdateListener(dtl.getDAG()),
634634 DTL(dtl), NodesToAnalyze(nta) {}
635635
636 virtual void NodeDeleted(SDNode *N, SDNode *E) {
636 void NodeDeleted(SDNode *N, SDNode *E) override {
637637 assert(N->getNodeId() != DAGTypeLegalizer::ReadyToProcess &&
638638 N->getNodeId() != DAGTypeLegalizer::Processed &&
639639 "Invalid node ID for RAUW deletion!");
654654 NodesToAnalyze.insert(E);
655655 }
656656
657 virtual void NodeUpdated(SDNode *N) {
657 void NodeUpdated(SDNode *N) override {
658658 // Node updates can mean pretty much anything. It is possible that an
659659 // operand was set to something already processed (f.e.) in which case
660660 // this node could become ready. Recompute its flags.
7979 ScheduleDAGFast(MachineFunction &mf)
8080 : ScheduleDAGSDNodes(mf) {}
8181
82 void Schedule();
82 void Schedule() override;
8383
8484 /// AddPred - adds a predecessor edge to SUnit SU.
8585 /// This returns true if this is a new predecessor.
106106 void ListScheduleBottomUp();
107107
108108 /// forceUnitLatencies - The fast scheduler doesn't care about real latencies.
109 bool forceUnitLatencies() const { return true; }
109 bool forceUnitLatencies() const override { return true; }
110110 };
111111 } // end anonymous namespace
112112
645645 public:
646646 ScheduleDAGLinearize(MachineFunction &mf) : ScheduleDAGSDNodes(mf) {}
647647
648 void Schedule();
649
650 MachineBasicBlock *EmitSchedule(MachineBasicBlock::iterator &InsertPos);
648 void Schedule() override;
649
650 MachineBasicBlock *
651 EmitSchedule(MachineBasicBlock::iterator &InsertPos) override;
651652
652653 private:
653654 std::vector Sequence;
176176 delete AvailableQueue;
177177 }
178178
179 void Schedule();
179 void Schedule() override;
180180
181181 ScheduleHazardRecognizer *getHazardRec() { return HazardRec; }
182182
260260
261261 /// forceUnitLatencies - Register-pressure-reducing scheduling doesn't
262262 /// need actual latency information but the hybrid scheduler does.
263 bool forceUnitLatencies() const {
263 bool forceUnitLatencies() const override {
264264 return !NeedLatency;
265265 }
266266 };
16741674 return scheduleDAG->getHazardRec();
16751675 }
16761676
1677 void initNodes(std::vector &sunits);
1678
1679 void addNode(const SUnit *SU);
1680
1681 void updateNode(const SUnit *SU);
1682
1683 void releaseState() {
1677 void initNodes(std::vector &sunits) override;
1678
1679 void addNode(const SUnit *SU) override;
1680
1681 void updateNode(const SUnit *SU) override;
1682
1683 void releaseState() override {
16841684 SUnits = 0;
16851685 SethiUllmanNumbers.clear();
16861686 std::fill(RegPressure.begin(), RegPressure.end(), 0);
16941694 return SU->getNode()->getIROrder();
16951695 }
16961696
1697 bool empty() const { return Queue.empty(); }
1698
1699 void push(SUnit *U) {
1697 bool empty() const override { return Queue.empty(); }
1698
1699 void push(SUnit *U) override {
17001700 assert(!U->NodeQueueId && "Node in the queue already");
17011701 U->NodeQueueId = ++CurQueueId;
17021702 Queue.push_back(U);
17031703 }
17041704
1705 void remove(SUnit *SU) {
1705 void remove(SUnit *SU) override {
17061706 assert(!Queue.empty() && "Queue is empty!");
17071707 assert(SU->NodeQueueId != 0 && "Not in queue!");
17081708 std::vector::iterator I = std::find(Queue.begin(), Queue.end(),
17131713 SU->NodeQueueId = 0;
17141714 }
17151715
1716 bool tracksRegPressure() const { return TracksRegPressure; }
1716 bool tracksRegPressure() const override { return TracksRegPressure; }
17171717
17181718 void dumpRegPressure() const;
17191719
17231723
17241724 int RegPressureDiff(SUnit *SU, unsigned &LiveUses) const;
17251725
1726 void scheduledNode(SUnit *SU);
1727
1728 void unscheduledNode(SUnit *SU);
1726 void scheduledNode(SUnit *SU) override;
1727
1728 void unscheduledNode(SUnit *SU) override;
17291729
17301730 protected:
17311731 bool canClobber(const SUnit *SU, const SUnit *Op);
17751775 tii, tri, tli),
17761776 Picker(this) {}
17771777
1778 bool isBottomUp() const { return SF::IsBottomUp; }
1779
1780 bool isReady(SUnit *U) const {
1778 bool isBottomUp() const override { return SF::IsBottomUp; }
1779
1780 bool isReady(SUnit *U) const override {
17811781 return Picker.HasReadyFilter && Picker.isReady(U, getCurCycle());
17821782 }
17831783
1784 SUnit *pop() {
1784 SUnit *pop() override {
17851785 if (Queue.empty()) return NULL;
17861786
17871787 SUnit *V = popFromQueue(Queue, Picker, scheduleDAG);
116116 virtual MachineBasicBlock*
117117 EmitSchedule(MachineBasicBlock::iterator &InsertPos);
118118
119 virtual void dumpNode(const SUnit *SU) const;
119 void dumpNode(const SUnit *SU) const override;
120120
121121 void dumpSchedule() const;
122122
123 virtual std::string getGraphNodeLabel(const SUnit *SU) const;
123 std::string getGraphNodeLabel(const SUnit *SU) const override;
124124
125 virtual std::string getDAGName() const;
125 std::string getDAGName() const override;
126126
127127 virtual void getCustomGraphFeatures(GraphWriter &GW) const;
128128
7979 delete AvailableQueue;
8080 }
8181
82 void Schedule();
82 void Schedule() override;
8383
8484 private:
8585 void releaseSucc(SUnit *SU, const SDep &D);
56735673 SDNode::use_iterator &UI;
56745674 SDNode::use_iterator &UE;
56755675
5676 virtual void NodeDeleted(SDNode *N, SDNode *E) {
5676 void NodeDeleted(SDNode *N, SDNode *E) override {
56775677 // Increment the iterator as needed.
56785678 while (UI != UE && N == *UI)
56795679 ++UI;
802802 /// NodeDeleted - Handle nodes deleted from the graph. If the node being
803803 /// deleted is the current ISelPosition node, update ISelPosition.
804804 ///
805 virtual void NodeDeleted(SDNode *N, SDNode *E) {
805 void NodeDeleted(SDNode *N, SDNode *E) override {
806806 if (ISelPosition == SelectionDAG::allnodes_iterator(N))
807807 ++ISelPosition;
808808 }