1 //===-- llvm/Target/TargetInstrItineraries.h - Scheduling -------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file describes the structures used for instruction itineraries and
11 // states. This is used by schedulers to determine instruction states and
14 //===----------------------------------------------------------------------===//
16 #ifndef LLVM_TARGET_TARGETINSTRITINERARIES_H
17 #define LLVM_TARGET_TARGETINSTRITINERARIES_H
21 //===----------------------------------------------------------------------===//
22 /// Instruction stage - These values represent a step in the execution of an
23 /// instruction. The latency represents the number of discrete time slots used
24 /// need to complete the stage. Units represent the choice of functional units
25 /// that can be used to complete the stage. Eg. IntUnit1, IntUnit2.
28 unsigned Cycles; ///< Length of stage in machine cycles
29 unsigned Units; ///< Choice of functional units
33 //===----------------------------------------------------------------------===//
34 /// Instruction itinerary - An itinerary represents a sequential series of steps
35 /// required to complete an instruction. Itineraries are represented as
36 /// sequences of instruction stages.
38 struct InstrItinerary {
39 unsigned First; ///< Index of first stage in itinerary
40 unsigned Last; ///< Index of last + 1 stage in itinerary
45 //===----------------------------------------------------------------------===//
46 /// Instruction itinerary Data - Itinerary data supplied by a subtarget to be
49 struct InstrItineraryData {
50 const InstrStage *Stages; ///< Array of stages selected
51 const InstrItinerary *Itineratries; ///< Array of itineraries selected
55 InstrItineraryData() : Stages(0), Itineratries(0) {}
56 InstrItineraryData(const InstrStage *S, const InstrItinerary *I)
57 : Stages(S), Itineratries(I) {}
59 /// isEmpty - Returns true if there are no itineraries.
61 bool isEmpty() const { return Itineratries == 0; }
63 /// begin - Return the first stage of the itinerary.
65 const InstrStage *begin(unsigned ItinClassIndx) const {
66 unsigned StageIdx = Itineratries[ItinClassIndx].First;
67 return Stages + StageIdx;
70 /// end - Return the last+1 stage of the itinerary.
72 const InstrStage *end(unsigned ItinClassIndx) const {
73 unsigned StageIdx = Itineratries[ItinClassIndx].Last;
74 return Stages + StageIdx;
77 /// getLatency - Return the scheduling latency of the given class. A
78 /// simple latency value for an instruction is an over-simplification
79 /// for some architectures, but it's a reasonable first approximation.
81 unsigned getLatency(unsigned ItinClassIndx) const {
82 // If the target doesn't provide latency information, use a simple
83 // non-zero default value for all instructions.
87 // Just sum the cycle count for each stage.
89 for (const InstrStage *IS = begin(ItinClassIndx), *E = end(ItinClassIndx);
91 Latency += IS->Cycles;
97 } // End llvm namespace