<html>
<head>
<base href="http://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 --- - usage of pointers to packed struct members should trigger warning"
href="http://llvm.org/bugs/show_bug.cgi?id=22821">22821</a>
</td>
</tr>
<tr>
<th>Summary</th>
<td>usage of pointers to packed struct members should trigger warning
</td>
</tr>
<tr>
<th>Product</th>
<td>clang
</td>
</tr>
<tr>
<th>Version</th>
<td>3.6
</td>
</tr>
<tr>
<th>Hardware</th>
<td>All
</td>
</tr>
<tr>
<th>OS</th>
<td>All
</td>
</tr>
<tr>
<th>Status</th>
<td>NEW
</td>
</tr>
<tr>
<th>Severity</th>
<td>enhancement
</td>
</tr>
<tr>
<th>Priority</th>
<td>P
</td>
</tr>
<tr>
<th>Component</th>
<td>Frontend
</td>
</tr>
<tr>
<th>Assignee</th>
<td>unassignedclangbugs@nondot.org
</td>
</tr>
<tr>
<th>Reporter</th>
<td>sven.koehler@gmail.com
</td>
</tr>
<tr>
<th>CC</th>
<td>llvmbugs@cs.uiuc.edu
</td>
</tr>
<tr>
<th>Classification</th>
<td>Unclassified
</td>
</tr></table>
<p>
<div>
<pre>clang, like gcc and other compilers, supports packed structs. This feature
exists for years (at least in gcc and microsoft compilers) and the dangers are
well known. In particular, pointers to members of a packed struct are basically
invalid as they don't satisfy the alignment assumptions that compilers usually
make. This results in crashing programs on ARM, SPARC, and maybe other
architectures. Consider the following example code and assume that int is 32
bit:
#include <stdio.h>
#pragma pack(1)
typedef struct { int v; } unaligned;
#pragma pack()
void print(int *x) { printf("%d\n", *x); }
void test1(unaligned *p) { print(&(p->v)); }
void test2(unaligned *p) {
int *x = &(p->v);
printf("%d\n", *x);
}
The type unaligned only provides an alignment guarantee of 1. Yet, I can assign
the pointer to p->v to an int* without any complaints by the compiler. I tried
-Weverything in combination with an arm target.
There is -Wcast-align, but it only seems to be triggered when casting char* to
int*. Again, char* only provides an alignment of 1 while int* needs an
alignment of 4.
I guess, the technical challenge here is to distinguish between an ordinary
int* with an alignment of 4 and a some special type of int* with an alignment
of 1. Note that by changing pack(1) into pack(2), we can easily create a struct
with an alignment guarantee of 2, so technically a pointer to an int16_t member
of the struct would be fine while a pointer to an int32_t member would not be
fine.
I'm aware of some discussion in the GCC bugzilla where they discuss introducing
variable attributes to indicate unaligned pointers and how gcc could track
alignment guarantees inside the scope so that, for example, test2 would work
out of the box. But anyhow, there needs to be some warning when a pointer with
a low alignment guarantee is assigned to some pointer variable with high
alignment guarantee as this will break on some architectures.</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>