1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
From bf02d4a98b284e865cda0422dcd5bef2cdc4d662 Mon Sep 17 00:00:00 2001
From: Larry Gritz <lg@larrygritz.com>
Date: Sun, 24 Oct 2021 15:29:08 -0700
Subject: [PATCH] Changes to work with LLVM 13 (#1420)
And a few places to let it compile with clang 13's new warnings.
Signed-off-by: Larry Gritz <lg@larrygritz.com>
---
src/include/OSL/llvm_util.h | 17 +++++++++--
src/liboslexec/llvm_util.cpp | 45 ++++++++++++++++++++++++++----
src/liboslexec/runtimeoptimize.cpp | 2 --
4 files changed, 62 insertions(+), 18 deletions(-)
diff --git a/src/include/OSL/llvm_util.h b/src/include/OSL/llvm_util.h
index fbf091d60..95df9632f 100644
--- a/src/include/OSL/llvm_util.h
+++ b/src/include/OSL/llvm_util.h
@@ -802,6 +802,9 @@ class OSLEXECPUBLIC LLVM_Util {
llvm::Value *src, int srcalign, int len);
/// Dereference a pointer: return *ptr
+ /// type is the type of the thing being pointed to.
+ llvm::Value *op_load (llvm::Type* type, llvm::Value *ptr);
+ // Blind pointer version that's deprecated as of LLVM13:
llvm::Value *op_load (llvm::Value *ptr);
llvm::Value *op_gather(llvm::Value *ptr, llvm::Value *index);
@@ -830,17 +833,25 @@ class OSLEXECPUBLIC LLVM_Util {
/// Generate a GEP (get element pointer) where the element index is an
/// llvm::Value, which can be generated from either a constant or a
- /// runtime-computed integer element index.
+ /// runtime-computed integer element index. `type` is the type of the data
+ /// we're retrieving.
+ llvm::Value *GEP (llvm::Type* type, llvm::Value *ptr, llvm::Value *elem);
+ // Blind pointer version that's deprecated as of LLVM13:
llvm::Value *GEP (llvm::Value *ptr, llvm::Value *elem);
/// Generate a GEP (get element pointer) with an integer element
- /// offset.
+ /// offset. `type` is the type of the data we're retrieving.
+ llvm::Value *GEP (llvm::Type* type, llvm::Value *ptr, int elem);
+ // Blind pointer version that's deprecated as of LLVM13:
llvm::Value *GEP (llvm::Value *ptr, int elem);
/// Generate a GEP (get element pointer) with two integer element
/// offsets. This is just a special (and common) case of GEP where
/// we have a 2-level hierarchy and we have fixed element indices
- /// that are known at compile time.
+ /// that are known at compile time. `type` is the type of the data we're
+ /// retrieving.
+ llvm::Value *GEP (llvm::Type* type, llvm::Value *ptr, int elem1, int elem2);
+ // Blind pointer version that's deprecated as of LLVM13:
llvm::Value *GEP (llvm::Value *ptr, int elem1, int elem2);
// Arithmetic ops. It auto-detects the type (int vs float).
diff --git a/src/liboslexec/llvm_util.cpp b/src/liboslexec/llvm_util.cpp
index 4d0e1752d..a1d31fe4d 100644
--- a/src/liboslexec/llvm_util.cpp
+++ b/src/liboslexec/llvm_util.cpp
@@ -3595,10 +3595,18 @@ LLVM_Util::op_memcpy (llvm::Value *dst, int dstalign,
+llvm::Value *
+LLVM_Util::op_load (llvm::Type* type, llvm::Value* ptr)
+{
+ return builder().CreateLoad (type, ptr);
+}
+
+
+
llvm::Value *
LLVM_Util::op_load (llvm::Value *ptr)
{
- return builder().CreateLoad (ptr);
+ return op_load(ptr->getType()->getPointerElementType(), ptr);
}
@@ -4883,7 +4891,7 @@ LLVM_Util::op_store (llvm::Value *val, llvm::Value *ptr)
// happen and a read+.
// TODO: Optimization, if we know this was the final store to
// the ptr, we could force a masked store vs. load/blend
- llvm::Value *previous_value = builder().CreateLoad (ptr);
+ llvm::Value *previous_value = op_load(ptr);
if (false == mi.negate) {
llvm::Value *blended_value = builder().CreateSelect(mi.mask, val, previous_value);
builder().CreateStore(blended_value, ptr);
@@ -4924,10 +4932,27 @@ LLVM_Util::op_store_mask (llvm::Value *llvm_mask, llvm::Value *native_mask_ptr)
+llvm::Value *
+LLVM_Util::GEP (llvm::Type* type, llvm::Value* ptr, llvm::Value* elem)
+{
+ return builder().CreateGEP(type, ptr, elem);
+}
+
+
+
llvm::Value *
LLVM_Util::GEP (llvm::Value *ptr, llvm::Value *elem)
{
- return builder().CreateGEP (ptr, elem);
+ return GEP(ptr->getType()->getScalarType()->getPointerElementType(), ptr,
+ elem);
+}
+
+
+
+llvm::Value *
+LLVM_Util::GEP (llvm::Type* type, llvm::Value* ptr, int elem)
+{
+ return builder().CreateConstGEP1_32(type, ptr, elem);
}
@@ -4935,7 +4960,16 @@ LLVM_Util::GEP (llvm::Value *ptr, llvm::Value *elem)
llvm::Value *
LLVM_Util::GEP (llvm::Value *ptr, int elem)
{
- return builder().CreateConstGEP1_32 (ptr, elem);
+ return GEP(ptr->getType()->getScalarType()->getPointerElementType(), ptr,
+ elem);
+}
+
+
+
+llvm::Value *
+LLVM_Util::GEP(llvm::Type* type, llvm::Value* ptr, int elem1, int elem2)
+{
+ return builder().CreateConstGEP2_32 (type, ptr, elem1, elem2);
}
@@ -4943,7 +4977,8 @@ LLVM_Util::GEP (llvm::Value *ptr, int elem)
llvm::Value *
LLVM_Util::GEP (llvm::Value *ptr, int elem1, int elem2)
{
- return builder().CreateConstGEP2_32 (nullptr, ptr, elem1, elem2);
+ return GEP(ptr->getType()->getScalarType()->getPointerElementType(), ptr,
+ elem1, elem2);
}
diff --git a/src/liboslexec/runtimeoptimize.cpp b/src/liboslexec/runtimeoptimize.cpp
index dfe554164..da67c712e 100644
--- a/src/liboslexec/runtimeoptimize.cpp
+++ b/src/liboslexec/runtimeoptimize.cpp
@@ -2284,7 +2284,6 @@ RuntimeOptimizer::optimize_instance ()
// passes, but we have a hard cutoff just to be sure we don't
// ever get into an infinite loop from an unforseen cycle where we
// end up inadvertently transforming A => B => A => etc.
- int totalchanged = 0;
int reallydone = 0; // Force a few passes after we think we're done
int npasses = shadingsys().opt_passes();
for (m_pass = 0; m_pass < npasses; ++m_pass) {
@@ -2345,7 +2344,6 @@ RuntimeOptimizer::optimize_instance ()
// If nothing changed, we're done optimizing. But wait, it may be
// that after re-tracking variable lifetimes, we can notice new
// optimizations! So force another pass, then we're really done.
- totalchanged += changed;
if (changed < 1) {
if (++reallydone > 3)
break;
|
