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 | |