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