1 //===- VNCoercion.h - Value Numbering Coercion Utilities --------*- 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 /// \file / This file provides routines used by LLVM's value numbering passes to 9 /// perform various forms of value extraction from memory when the types are not 10 /// identical. For example, given 11 /// 12 /// store i32 8, i32 *%foo 13 /// %a = bitcast i32 *%foo to i16 14 /// %val = load i16, i16 *%a 15 /// 16 /// It possible to extract the value of the load of %a from the store to %foo. 17 /// These routines know how to tell whether they can do that (the analyze* 18 /// routines), and can also insert the necessary IR to do it (the get* 19 /// routines). 20 21 #ifndef LLVM_TRANSFORMS_UTILS_VNCOERCION_H 22 #define LLVM_TRANSFORMS_UTILS_VNCOERCION_H 23 24 namespace llvm { 25 class Constant; 26 class StoreInst; 27 class LoadInst; 28 class MemIntrinsic; 29 class Instruction; 30 class IRBuilderBase; 31 class Value; 32 class Type; 33 class DataLayout; 34 namespace VNCoercion { 35 /// Return true if CoerceAvailableValueToLoadType would succeed if it was 36 /// called. 37 bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy, 38 const DataLayout &DL); 39 40 /// If we saw a store of a value to memory, and then a load from a must-aliased 41 /// pointer of a different type, try to coerce the stored value to the loaded 42 /// type. LoadedTy is the type of the load we want to replace. IRB is 43 /// IRBuilder used to insert new instructions. 44 /// 45 /// If we can't do it, return null. 46 Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy, 47 IRBuilderBase &IRB, const DataLayout &DL); 48 49 /// This function determines whether a value for the pointer LoadPtr can be 50 /// extracted from the store at DepSI. 51 /// 52 /// On success, it returns the offset into DepSI that extraction would start. 53 /// On failure, it returns -1. 54 int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr, 55 StoreInst *DepSI, const DataLayout &DL); 56 57 /// This function determines whether a value for the pointer LoadPtr can be 58 /// extracted from the load at DepLI. 59 /// 60 /// On success, it returns the offset into DepLI that extraction would start. 61 /// On failure, it returns -1. 62 int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI, 63 const DataLayout &DL); 64 65 /// This function determines whether a value for the pointer LoadPtr can be 66 /// extracted from the memory intrinsic at DepMI. 67 /// 68 /// On success, it returns the offset into DepMI that extraction would start. 69 /// On failure, it returns -1. 70 int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr, 71 MemIntrinsic *DepMI, const DataLayout &DL); 72 73 /// If analyzeLoadFromClobberingStore/Load returned an offset, this function 74 /// can be used to actually perform the extraction of the bits from the store. 75 /// It inserts instructions to do so at InsertPt, and returns the extracted 76 /// value. 77 Value *getValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy, 78 Instruction *InsertPt, const DataLayout &DL); 79 // This is the same as getValueForLoad, except it performs no insertion. 80 // It only allows constant inputs. 81 Constant *getConstantValueForLoad(Constant *SrcVal, unsigned Offset, 82 Type *LoadTy, const DataLayout &DL); 83 84 /// If analyzeLoadFromClobberingMemInst returned an offset, this function can be 85 /// used to actually perform the extraction of the bits from the memory 86 /// intrinsic. It inserts instructions to do so at InsertPt, and returns the 87 /// extracted value. 88 Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset, 89 Type *LoadTy, Instruction *InsertPt, 90 const DataLayout &DL); 91 // This is the same as getStoreValueForLoad, except it performs no insertion. 92 // It returns nullptr if it cannot produce a constant. 93 Constant *getConstantMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset, 94 Type *LoadTy, const DataLayout &DL); 95 } 96 } 97 #endif 98