LLVM  12.0.0git
Annotation2Metadata.cpp
Go to the documentation of this file.
1 //===-- Annotation2Metadata.cpp - Add !annotation metadata. ---------------===//
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 // Add !annotation metadata for entries in @llvm.global.anotations, generated
10 // using __attribute__((annotate("_name"))) on functions in Clang.
11 //
12 //===----------------------------------------------------------------------===//
13 
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/InstIterator.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/InitializePasses.h"
21 #include "llvm/Pass.h"
22 #include "llvm/Transforms/IPO.h"
23 
24 using namespace llvm;
25 
26 #define DEBUG_TYPE "annotation2metadata"
27 
29  // Only add !annotation metadata if the corresponding remarks pass is also
30  // enabled.
32  "annotation-remarks"))
33  return false;
34 
35  auto *Annotations = M.getGlobalVariable("llvm.global.annotations");
36  auto *C = dyn_cast_or_null<Constant>(Annotations);
37  if (!C || C->getNumOperands() != 1)
38  return false;
39 
40  C = cast<Constant>(C->getOperand(0));
41 
42  // Iterate over all entries in C and attach !annotation metadata to suitable
43  // entries.
44  for (auto &Op : C->operands()) {
45  // Look at the operands to check if we can use the entry to generate
46  // !annotation metadata.
47  auto *OpC = dyn_cast<ConstantStruct>(&Op);
48  if (!OpC || OpC->getNumOperands() != 4)
49  continue;
50  auto *StrGEP = dyn_cast<ConstantExpr>(OpC->getOperand(1));
51  if (!StrGEP || StrGEP->getNumOperands() < 2)
52  continue;
53  auto *StrC = dyn_cast<GlobalValue>(StrGEP->getOperand(0));
54  if (!StrC)
55  continue;
56  auto *StrData = dyn_cast<ConstantDataSequential>(StrC->getOperand(0));
57  if (!StrData)
58  continue;
59  // Look through bitcast.
60  auto *Bitcast = dyn_cast<ConstantExpr>(OpC->getOperand(0));
61  if (!Bitcast || Bitcast->getOpcode() != Instruction::BitCast)
62  continue;
63  auto *Fn = dyn_cast<Function>(Bitcast->getOperand(0));
64  if (!Fn)
65  continue;
66 
67  // Add annotation to all instructions in the function.
68  for (auto &I : instructions(Fn))
69  I.addAnnotationMetadata(StrData->getAsCString());
70  }
71  return true;
72 }
73 
74 namespace {
75 struct Annotation2MetadataLegacy : public ModulePass {
76  static char ID;
77 
78  Annotation2MetadataLegacy() : ModulePass(ID) {
80  }
81 
82  bool runOnModule(Module &M) override { return convertAnnotation2Metadata(M); }
83 
84  void getAnalysisUsage(AnalysisUsage &AU) const override {
85  AU.setPreservesAll();
86  }
87 };
88 
89 } // end anonymous namespace
90 
92 
93 INITIALIZE_PASS_BEGIN(Annotation2MetadataLegacy, DEBUG_TYPE,
94  "Annotation2Metadata", false, false)
95 INITIALIZE_PASS_END(Annotation2MetadataLegacy, DEBUG_TYPE,
97 
99  return new Annotation2MetadataLegacy();
100 }
101 
103  ModuleAnalysisManager &AM) {
105  return PreservedAnalyses::all();
106 }
uint64_t CallInst * C
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
void initializeAnnotation2MetadataLegacyPass(PassRegistry &)
Value * getOperand(unsigned i) const
Definition: User.h:169
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Represent the analysis usage information of a pass.
op_range operands()
Definition: User.h:242
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
bool allowExtraAnalysis(StringRef PassName) const
Whether we allow for extra compile-time budget to perform more analysis to produce fewer false positi...
unsigned getNumOperands() const
Definition: User.h:191
Perform the operation on a different, but equivalently sized type.
Definition: LegalizerInfo.h:73
ModulePass * createAnnotation2MetadataLegacyPass()
Module.h This file contains the declarations for the Module class.
void setPreservesAll()
Set by analyses that do not transform their input at all.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
#define I(x, y, z)
Definition: MD5.cpp:59
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:238
#define DEBUG_TYPE
INITIALIZE_PASS_BEGIN(Annotation2MetadataLegacy, DEBUG_TYPE, "Annotation2Metadata", false, false) INITIALIZE_PASS_END(Annotation2MetadataLegacy
static bool convertAnnotation2Metadata(Module &M)
Annotation2Metadata
inst_range instructions(Function *F)
Definition: InstIterator.h:133
A container for analyses that lazily runs them and caches their results.
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:46