<html>
<head>
<base href="https://llvm.org/bugs/" />
</head>
<body><table border="1" cellspacing="0" cellpadding="8">
<tr>
<th>Bug ID</th>
<td><a class="bz_bug_link
bz_status_NEW "
title="NEW --- - Doing certain kinds of IPO over comdat functions is unsound"
href="https://llvm.org/bugs/show_bug.cgi?id=26774">26774</a>
</td>
</tr>
<tr>
<th>Summary</th>
<td>Doing certain kinds of IPO over comdat functions is unsound
</td>
</tr>
<tr>
<th>Product</th>
<td>libraries
</td>
</tr>
<tr>
<th>Version</th>
<td>trunk
</td>
</tr>
<tr>
<th>Hardware</th>
<td>PC
</td>
</tr>
<tr>
<th>OS</th>
<td>All
</td>
</tr>
<tr>
<th>Status</th>
<td>NEW
</td>
</tr>
<tr>
<th>Severity</th>
<td>normal
</td>
</tr>
<tr>
<th>Priority</th>
<td>P
</td>
</tr>
<tr>
<th>Component</th>
<td>Interprocedural Optimizations
</td>
</tr>
<tr>
<th>Assignee</th>
<td>unassignedbugs@nondot.org
</td>
</tr>
<tr>
<th>Reporter</th>
<td>sanjoy@playingwithpointers.com
</td>
</tr>
<tr>
<th>CC</th>
<td>llvm-bugs@lists.llvm.org
</td>
</tr>
<tr>
<th>Classification</th>
<td>Unclassified
</td>
</tr></table>
<p>
<div>
<pre>Created <span class=""><a href="attachment.cgi?id=15960" name="attach_15960" title="Reproducer">attachment 15960</a> <a href="attachment.cgi?id=15960&action=edit" title="Reproducer">[details]</a></span>
Reproducer
This was discussed on llvm-dev:
<a href="http://lists.llvm.org/pipermail/llvm-dev/2016-February/095833.html">http://lists.llvm.org/pipermail/llvm-dev/2016-February/095833.html</a>
Description copy-pasted from the thread:
"""
Let's start with an example that shows that we have a problem (direct
copy/paste from the guard intrinsics thread). Say we have:
```
void foo() available_externally {
%t0 = load atomic %ptr
%t1 = load atomic %ptr
if (%t0 != %t1) print("X");
}
void main() {
foo();
print("Y");
}
```
The possible behaviors of the above program are {print("X"),
print("Y")} or {print("Y")}. But if we run opt then we have
```
void foo() available_externally readnone nounwind {
;; After CSE'ing the two loads and folding the condition
}
void main() {
foo();
print("Y");
}
```
and some generic reordering
```
void foo() available_externally readnone nounwind {
;; After CSE'ing the two loads and folding the condition
}
void main() {
print("Y");
foo(); // legal since we're moving a readnone nounwind function that
// was guaranteed to execute (hence can't have UB)
}
```
If we do not inline @foo(), and instead re-link the call site in @main
to some non-optimized copy (or differently optimized copy) of @foo,
then it is possible for the program to have the behavior {print("Y");
print ("X")}, which was disallowed in the earlier program.
In other words, opt refined the semantics of @foo() (i.e. reduced the
set of behaviors it may have) in ways that would make later
optimizations invalid if we de-refine the implementation of @foo().
The above example is clearly fabricated, but such cases can come up
even if everything is optimized to the same level. E.g. one of the
atomic loads in the unrefined implementation of @foo() could have been
hidden behind a function call, whose body existed in only one module.
That module would then be able to refine @foo() to `ret void` but
other modules won't.
"""</pre>
</div>
</p>
<hr>
<span>You are receiving this mail because:</span>
<ul>
<li>You are on the CC list for the bug.</li>
</ul>
</body>
</html>