LLVM 19.0.0git
VNCoercion.h
Go to the documentation of this file.
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
24namespace llvm {
25class Constant;
26class StoreInst;
27class LoadInst;
28class MemIntrinsic;
29class Instruction;
30class IRBuilderBase;
31class Value;
32class Type;
33class DataLayout;
34namespace VNCoercion {
35/// Return true if CoerceAvailableValueToLoadType would succeed if it was
36/// called.
37bool 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.
46Value *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.
54int 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.
62int 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.
70int 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.
77Value *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.
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.
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.
94 Type *LoadTy, const DataLayout &DL);
95}
96}
97#endif
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
RelocType Type
Definition: COFFYAML.cpp:391
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:94
An instruction for reading from memory.
Definition: Instructions.h:185
This is the common base class for memset/memcpy/memmove.
An instruction for storing to memory.
Definition: Instructions.h:318
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
Value * getValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy, Instruction *InsertPt, const DataLayout &DL)
If analyzeLoadFromClobberingStore/Load returned an offset, this function can be used to actually perf...
Definition: VNCoercion.cpp:335
Value * coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy, IRBuilderBase &IRB, const DataLayout &DL)
If we saw a store of a value to memory, and then a load from a must-aliased pointer of a different ty...
Definition: VNCoercion.cpp:76
int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr, StoreInst *DepSI, const DataLayout &DL)
This function determines whether a value for the pointer LoadPtr can be extracted from the store at D...
Definition: VNCoercion.cpp:211
Value * getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset, Type *LoadTy, Instruction *InsertPt, const DataLayout &DL)
If analyzeLoadFromClobberingMemInst returned an offset, this function can be used to actually perform...
Definition: VNCoercion.cpp:360
Constant * getConstantValueForLoad(Constant *SrcVal, unsigned Offset, Type *LoadTy, const DataLayout &DL)
Definition: VNCoercion.cpp:348
int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI, const DataLayout &DL)
This function determines whether a value for the pointer LoadPtr can be extracted from the load at De...
Definition: VNCoercion.cpp:232
Constant * getConstantMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset, Type *LoadTy, const DataLayout &DL)
Definition: VNCoercion.cpp:407
int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr, MemIntrinsic *DepMI, const DataLayout &DL)
This function determines whether a value for the pointer LoadPtr can be extracted from the memory int...
Definition: VNCoercion.cpp:246
bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy, const DataLayout &DL)
Return true if CoerceAvailableValueToLoadType would succeed if it was called.
Definition: VNCoercion.cpp:18
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456