clang  3.7.0
CGLoopInfo.cpp
Go to the documentation of this file.
1 //===---- CGLoopInfo.cpp - LLVM CodeGen for loop metadata -*- C++ -*-------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "CGLoopInfo.h"
11 #include "clang/AST/Attr.h"
12 #include "clang/Sema/LoopHint.h"
13 #include "llvm/IR/BasicBlock.h"
14 #include "llvm/IR/Constants.h"
15 #include "llvm/IR/InstrTypes.h"
16 #include "llvm/IR/Instructions.h"
17 #include "llvm/IR/Metadata.h"
18 using namespace clang::CodeGen;
19 using namespace llvm;
20 
21 static MDNode *createMetadata(LLVMContext &Ctx, const LoopAttributes &Attrs) {
22 
23  if (!Attrs.IsParallel && Attrs.VectorizerWidth == 0 &&
24  Attrs.VectorizerUnroll == 0 &&
26  return nullptr;
27 
29  // Reserve operand 0 for loop id self reference.
30  auto TempNode = MDNode::getTemporary(Ctx, None);
31  Args.push_back(TempNode.get());
32 
33  // Setting vectorizer.width
34  if (Attrs.VectorizerWidth > 0) {
35  Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.vectorize.width"),
36  ConstantAsMetadata::get(ConstantInt::get(
37  Type::getInt32Ty(Ctx), Attrs.VectorizerWidth))};
38  Args.push_back(MDNode::get(Ctx, Vals));
39  }
40 
41  // Setting vectorizer.unroll
42  if (Attrs.VectorizerUnroll > 0) {
43  Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.interleave.count"),
44  ConstantAsMetadata::get(ConstantInt::get(
45  Type::getInt32Ty(Ctx), Attrs.VectorizerUnroll))};
46  Args.push_back(MDNode::get(Ctx, Vals));
47  }
48 
49  // Setting vectorizer.enable
51  Metadata *Vals[] = {
52  MDString::get(Ctx, "llvm.loop.vectorize.enable"),
53  ConstantAsMetadata::get(ConstantInt::get(
54  Type::getInt1Ty(Ctx),
56  Args.push_back(MDNode::get(Ctx, Vals));
57  }
58 
59  // Set the first operand to itself.
60  MDNode *LoopID = MDNode::get(Ctx, Args);
61  LoopID->replaceOperandWith(0, LoopID);
62  return LoopID;
63 }
64 
66  : IsParallel(IsParallel), VectorizerEnable(LoopAttributes::VecUnspecified),
67  VectorizerWidth(0), VectorizerUnroll(0) {}
68 
70  IsParallel = false;
71  VectorizerWidth = 0;
72  VectorizerUnroll = 0;
74 }
75 
76 LoopInfo::LoopInfo(BasicBlock *Header, const LoopAttributes &Attrs)
77  : LoopID(nullptr), Header(Header), Attrs(Attrs) {
78  LoopID = createMetadata(Header->getContext(), Attrs);
79 }
80 
81 void LoopInfoStack::push(BasicBlock *Header,
83  for (const auto *Attr : Attrs) {
84  const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(Attr);
85 
86  // Skip non loop hint attributes
87  if (!LH)
88  continue;
89 
90  LoopHintAttr::OptionType Option = LH->getOption();
91  LoopHintAttr::LoopHintState State = LH->getState();
92  switch (Option) {
93  case LoopHintAttr::Vectorize:
94  case LoopHintAttr::Interleave:
95  if (State == LoopHintAttr::AssumeSafety) {
96  // Apply "llvm.mem.parallel_loop_access" metadata to load/stores.
97  setParallel(true);
98  }
99  break;
100  case LoopHintAttr::VectorizeWidth:
101  case LoopHintAttr::InterleaveCount:
102  case LoopHintAttr::Unroll:
103  case LoopHintAttr::UnrollCount:
104  // Nothing to do here for these loop hints.
105  break;
106  }
107  }
108 
109  Active.push_back(LoopInfo(Header, StagedAttrs));
110  // Clear the attributes so nested loops do not inherit them.
111  StagedAttrs.clear();
112 }
113 
115  assert(!Active.empty() && "No active loops to pop");
116  Active.pop_back();
117 }
118 
119 void LoopInfoStack::InsertHelper(Instruction *I) const {
120  if (!hasInfo())
121  return;
122 
123  const LoopInfo &L = getInfo();
124  if (!L.getLoopID())
125  return;
126 
127  if (TerminatorInst *TI = dyn_cast<TerminatorInst>(I)) {
128  for (unsigned i = 0, ie = TI->getNumSuccessors(); i < ie; ++i)
129  if (TI->getSuccessor(i) == L.getHeader()) {
130  TI->setMetadata("llvm.loop", L.getLoopID());
131  break;
132  }
133  return;
134  }
135 
136  if (L.getAttributes().IsParallel && I->mayReadOrWriteMemory())
137  I->setMetadata("llvm.mem.parallel_loop_access", L.getLoopID());
138 }
Attributes that may be specified on loops.
Definition: CGLoopInfo.h:35
Information used when generating a structured loop.
Definition: CGLoopInfo.h:56
LoopAttributes(bool IsParallel=false)
Definition: CGLoopInfo.cpp:65
llvm::BasicBlock * getHeader() const
Get the header block of this loop.
Definition: CGLoopInfo.h:65
LineState State
void pop()
End the current loop.
Definition: CGLoopInfo.cpp:114
unsigned VectorizerUnroll
llvm.loop.interleave.count
Definition: CGLoopInfo.h:52
LVEnableState VectorizerEnable
llvm.loop.vectorize.enable
Definition: CGLoopInfo.h:46
llvm::MDNode * getLoopID() const
Get the loop id metadata for this loop.
Definition: CGLoopInfo.h:62
bool IsParallel
Generate llvm.loop.parallel metadata for loads and stores.
Definition: CGLoopInfo.h:40
void setParallel(bool Enable=true)
Set the next pushed loop as parallel.
Definition: CGLoopInfo.h:110
static MDNode * createMetadata(LLVMContext &Ctx, const LoopAttributes &Attrs)
Definition: CGLoopInfo.cpp:21
unsigned VectorizerWidth
llvm.loop.vectorize.width
Definition: CGLoopInfo.h:49
LoopInfo(llvm::BasicBlock *Header, const LoopAttributes &Attrs)
Construct a new LoopInfo for the loop with entry Header.
Definition: CGLoopInfo.cpp:76
void InsertHelper(llvm::Instruction *I) const
Function called by the CodeGenFunction when an instruction is created.
Definition: CGLoopInfo.cpp:119
const LoopAttributes & getAttributes() const
Get the set of attributes active for this loop.
Definition: CGLoopInfo.h:68
void push(llvm::BasicBlock *Header, llvm::ArrayRef< const Attr * > Attrs=llvm::None)
Begin a new structured loop. The set of staged attributes will be applied to the loop and then cleare...
Definition: CGLoopInfo.cpp:81
Attr - This represents one attribute.
Definition: Attr.h:44