1 //===---- CGLoopInfo.h - LLVM CodeGen for loop metadata -*- C++ -*---------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This is the internal state used for llvm translation for loop statement 10 // metadata. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_LIB_CODEGEN_CGLOOPINFO_H 15 #define LLVM_CLANG_LIB_CODEGEN_CGLOOPINFO_H 16 17 #include "llvm/ADT/ArrayRef.h" 18 #include "llvm/ADT/SmallVector.h" 19 #include "llvm/IR/DebugLoc.h" 20 #include "llvm/IR/Value.h" 21 #include "llvm/Support/Compiler.h" 22 23 namespace llvm { 24 class BasicBlock; 25 class Instruction; 26 class MDNode; 27 } // end namespace llvm 28 29 namespace clang { 30 class Attr; 31 class ASTContext; 32 class CodeGenOptions; 33 namespace CodeGen { 34 35 /// Attributes that may be specified on loops. 36 struct LoopAttributes { 37 explicit LoopAttributes(bool IsParallel = false); 38 void clear(); 39 40 /// Generate llvm.loop.parallel metadata for loads and stores. 41 bool IsParallel; 42 43 /// State of loop vectorization or unrolling. 44 enum LVEnableState { Unspecified, Enable, Disable, Full }; 45 46 /// Value for llvm.loop.vectorize.enable metadata. 47 LVEnableState VectorizeEnable; 48 49 /// Value for llvm.loop.unroll.* metadata (enable, disable, or full). 50 LVEnableState UnrollEnable; 51 52 /// Value for llvm.loop.unroll_and_jam.* metadata (enable, disable, or full). 53 LVEnableState UnrollAndJamEnable; 54 55 /// Value for llvm.loop.vectorize.predicate metadata 56 LVEnableState VectorizePredicateEnable; 57 58 /// Value for llvm.loop.vectorize.width metadata. 59 unsigned VectorizeWidth; 60 61 // Value for llvm.loop.vectorize.scalable.enable 62 LVEnableState VectorizeScalable; 63 64 /// Value for llvm.loop.interleave.count metadata. 65 unsigned InterleaveCount; 66 67 /// llvm.unroll. 68 unsigned UnrollCount; 69 70 /// llvm.unroll. 71 unsigned UnrollAndJamCount; 72 73 /// Value for llvm.loop.distribute.enable metadata. 74 LVEnableState DistributeEnable; 75 76 /// Value for llvm.loop.pipeline.disable metadata. 77 bool PipelineDisabled; 78 79 /// Value for llvm.loop.pipeline.iicount metadata. 80 unsigned PipelineInitiationInterval; 81 82 /// Value for 'llvm.loop.align' metadata. 83 unsigned CodeAlign; 84 85 /// Value for whether the loop is required to make progress. 86 bool MustProgress; 87 }; 88 89 /// Information used when generating a structured loop. 90 class LoopInfo { 91 public: 92 /// Construct a new LoopInfo for the loop with entry Header. 93 LoopInfo(llvm::BasicBlock *Header, const LoopAttributes &Attrs, 94 const llvm::DebugLoc &StartLoc, const llvm::DebugLoc &EndLoc, 95 LoopInfo *Parent); 96 97 /// Get the loop id metadata for this loop. 98 llvm::MDNode *getLoopID() const { return TempLoopID.get(); } 99 100 /// Get the header block of this loop. 101 llvm::BasicBlock *getHeader() const { return Header; } 102 103 /// Get the set of attributes active for this loop. 104 const LoopAttributes &getAttributes() const { return Attrs; } 105 106 /// Return this loop's access group or nullptr if it does not have one. 107 llvm::MDNode *getAccessGroup() const { return AccGroup; } 108 109 /// Create the loop's metadata. Must be called after its nested loops have 110 /// been processed. 111 void finish(); 112 113 /// Returns the first outer loop containing this loop if any, nullptr 114 /// otherwise. 115 const LoopInfo *getParent() const { return Parent; } 116 117 private: 118 /// Loop ID metadata. 119 llvm::TempMDTuple TempLoopID; 120 /// Header block of this loop. 121 llvm::BasicBlock *Header; 122 /// The attributes for this loop. 123 LoopAttributes Attrs; 124 /// The access group for memory accesses parallel to this loop. 125 llvm::MDNode *AccGroup = nullptr; 126 /// Start location of this loop. 127 llvm::DebugLoc StartLoc; 128 /// End location of this loop. 129 llvm::DebugLoc EndLoc; 130 /// The next outer loop, or nullptr if this is the outermost loop. 131 LoopInfo *Parent; 132 /// If this loop has unroll-and-jam metadata, this can be set by the inner 133 /// loop's LoopInfo to set the llvm.loop.unroll_and_jam.followup_inner 134 /// metadata. 135 llvm::MDNode *UnrollAndJamInnerFollowup = nullptr; 136 137 /// Create a LoopID without any transformations. 138 llvm::MDNode * 139 createLoopPropertiesMetadata(llvm::ArrayRef<llvm::Metadata *> LoopProperties); 140 141 /// Create a LoopID for transformations. 142 /// 143 /// The methods call each other in case multiple transformations are applied 144 /// to a loop. The transformation first to be applied will use LoopID of the 145 /// next transformation in its followup attribute. 146 /// 147 /// @param Attrs The loop's transformations. 148 /// @param LoopProperties Non-transformation properties such as debug 149 /// location, parallel accesses and disabled 150 /// transformations. These are added to the returned 151 /// LoopID. 152 /// @param HasUserTransforms [out] Set to true if the returned MDNode encodes 153 /// at least one transformation. 154 /// 155 /// @return A LoopID (metadata node) that can be used for the llvm.loop 156 /// annotation or followup-attribute. 157 /// @{ 158 llvm::MDNode * 159 createPipeliningMetadata(const LoopAttributes &Attrs, 160 llvm::ArrayRef<llvm::Metadata *> LoopProperties, 161 bool &HasUserTransforms); 162 llvm::MDNode * 163 createPartialUnrollMetadata(const LoopAttributes &Attrs, 164 llvm::ArrayRef<llvm::Metadata *> LoopProperties, 165 bool &HasUserTransforms); 166 llvm::MDNode * 167 createUnrollAndJamMetadata(const LoopAttributes &Attrs, 168 llvm::ArrayRef<llvm::Metadata *> LoopProperties, 169 bool &HasUserTransforms); 170 llvm::MDNode * 171 createLoopVectorizeMetadata(const LoopAttributes &Attrs, 172 llvm::ArrayRef<llvm::Metadata *> LoopProperties, 173 bool &HasUserTransforms); 174 llvm::MDNode * 175 createLoopDistributeMetadata(const LoopAttributes &Attrs, 176 llvm::ArrayRef<llvm::Metadata *> LoopProperties, 177 bool &HasUserTransforms); 178 llvm::MDNode * 179 createFullUnrollMetadata(const LoopAttributes &Attrs, 180 llvm::ArrayRef<llvm::Metadata *> LoopProperties, 181 bool &HasUserTransforms); 182 /// @} 183 184 /// Create a LoopID for this loop, including transformation-unspecific 185 /// metadata such as debug location. 186 /// 187 /// @param Attrs This loop's attributes and transformations. 188 /// @param LoopProperties Additional non-transformation properties to add 189 /// to the LoopID, such as transformation-specific 190 /// metadata that are not covered by @p Attrs. 191 /// @param HasUserTransforms [out] Set to true if the returned MDNode encodes 192 /// at least one transformation. 193 /// 194 /// @return A LoopID (metadata node) that can be used for the llvm.loop 195 /// annotation. 196 llvm::MDNode *createMetadata(const LoopAttributes &Attrs, 197 llvm::ArrayRef<llvm::Metadata *> LoopProperties, 198 bool &HasUserTransforms); 199 }; 200 201 /// A stack of loop information corresponding to loop nesting levels. 202 /// This stack can be used to prepare attributes which are applied when a loop 203 /// is emitted. 204 class LoopInfoStack { 205 LoopInfoStack(const LoopInfoStack &) = delete; 206 void operator=(const LoopInfoStack &) = delete; 207 208 public: 209 LoopInfoStack() {} 210 211 /// Begin a new structured loop. The set of staged attributes will be 212 /// applied to the loop and then cleared. 213 void push(llvm::BasicBlock *Header, const llvm::DebugLoc &StartLoc, 214 const llvm::DebugLoc &EndLoc); 215 216 /// Begin a new structured loop. Stage attributes from the Attrs list. 217 /// The staged attributes are applied to the loop and then cleared. 218 void push(llvm::BasicBlock *Header, clang::ASTContext &Ctx, 219 const clang::CodeGenOptions &CGOpts, 220 llvm::ArrayRef<const Attr *> Attrs, const llvm::DebugLoc &StartLoc, 221 const llvm::DebugLoc &EndLoc, bool MustProgress = false); 222 223 /// End the current loop. 224 void pop(); 225 226 /// Return the top loop id metadata. 227 llvm::MDNode *getCurLoopID() const { return getInfo().getLoopID(); } 228 229 /// Return true if the top loop is parallel. 230 bool getCurLoopParallel() const { 231 return hasInfo() ? getInfo().getAttributes().IsParallel : false; 232 } 233 234 /// Function called by the CodeGenFunction when an instruction is 235 /// created. 236 void InsertHelper(llvm::Instruction *I) const; 237 238 /// Set the next pushed loop as parallel. 239 void setParallel(bool Enable = true) { StagedAttrs.IsParallel = Enable; } 240 241 /// Set the next pushed loop 'vectorize.enable' 242 void setVectorizeEnable(bool Enable = true) { 243 StagedAttrs.VectorizeEnable = 244 Enable ? LoopAttributes::Enable : LoopAttributes::Disable; 245 } 246 247 /// Set the next pushed loop as a distribution candidate. 248 void setDistributeState(bool Enable = true) { 249 StagedAttrs.DistributeEnable = 250 Enable ? LoopAttributes::Enable : LoopAttributes::Disable; 251 } 252 253 /// Set the next pushed loop unroll state. 254 void setUnrollState(const LoopAttributes::LVEnableState &State) { 255 StagedAttrs.UnrollEnable = State; 256 } 257 258 /// Set the next pushed vectorize predicate state. 259 void setVectorizePredicateState(const LoopAttributes::LVEnableState &State) { 260 StagedAttrs.VectorizePredicateEnable = State; 261 } 262 263 /// Set the next pushed loop unroll_and_jam state. 264 void setUnrollAndJamState(const LoopAttributes::LVEnableState &State) { 265 StagedAttrs.UnrollAndJamEnable = State; 266 } 267 268 /// Set the vectorize width for the next loop pushed. 269 void setVectorizeWidth(unsigned W) { StagedAttrs.VectorizeWidth = W; } 270 271 void setVectorizeScalable(const LoopAttributes::LVEnableState &State) { 272 StagedAttrs.VectorizeScalable = State; 273 } 274 275 /// Set the interleave count for the next loop pushed. 276 void setInterleaveCount(unsigned C) { StagedAttrs.InterleaveCount = C; } 277 278 /// Set the unroll count for the next loop pushed. 279 void setUnrollCount(unsigned C) { StagedAttrs.UnrollCount = C; } 280 281 /// \brief Set the unroll count for the next loop pushed. 282 void setUnrollAndJamCount(unsigned C) { StagedAttrs.UnrollAndJamCount = C; } 283 284 /// Set the pipeline disabled state. 285 void setPipelineDisabled(bool S) { StagedAttrs.PipelineDisabled = S; } 286 287 /// Set the pipeline initiation interval. 288 void setPipelineInitiationInterval(unsigned C) { 289 StagedAttrs.PipelineInitiationInterval = C; 290 } 291 292 /// Set value of code align for the next loop pushed. 293 void setCodeAlign(unsigned C) { StagedAttrs.CodeAlign = C; } 294 295 /// Set no progress for the next loop pushed. 296 void setMustProgress(bool P) { StagedAttrs.MustProgress = P; } 297 298 /// Returns true if there is LoopInfo on the stack. 299 bool hasInfo() const { return !Active.empty(); } 300 /// Return the LoopInfo for the current loop. HasInfo should be called 301 /// first to ensure LoopInfo is present. 302 const LoopInfo &getInfo() const { return *Active.back(); } 303 304 private: 305 /// The set of attributes that will be applied to the next pushed loop. 306 LoopAttributes StagedAttrs; 307 /// Stack of active loops. 308 llvm::SmallVector<std::unique_ptr<LoopInfo>, 4> Active; 309 }; 310 311 } // end namespace CodeGen 312 } // end namespace clang 313 314 #endif 315