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 14 #include "llvm/Transforms/IPO/Annotation2Metadata.h" 15 #include "llvm/Analysis/OptimizationRemarkEmitter.h" 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 28 static bool convertAnnotation2Metadata(Module &M) { 29 // Only add !annotation metadata if the corresponding remarks pass is also 30 // enabled. 31 if (!OptimizationRemarkEmitter::allowExtraAnalysis(M.getContext(), 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) { 79 initializeAnnotation2MetadataLegacyPass(*PassRegistry::getPassRegistry()); 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 91 char Annotation2MetadataLegacy::ID = 0; 92 93 INITIALIZE_PASS_BEGIN(Annotation2MetadataLegacy, DEBUG_TYPE, 94 "Annotation2Metadata", false, false) 95 INITIALIZE_PASS_END(Annotation2MetadataLegacy, DEBUG_TYPE, 96 "Annotation2Metadata", false, false) 97 98 ModulePass *llvm::createAnnotation2MetadataLegacyPass() { 99 return new Annotation2MetadataLegacy(); 100 } 101 102 PreservedAnalyses Annotation2MetadataPass::run(Module &M, 103 ModuleAnalysisManager &AM) { 104 convertAnnotation2Metadata(M); 105 return PreservedAnalyses::all(); 106 } 107