"ifunc resolver function must return a pointer">;
def warn_atomic_op_misaligned : Warning<
- "%select{large|misaligned}0 atomic operation may incur "
- "significant performance penalty">, InGroup<DiagGroup<"atomic-alignment">>;
+ "misaligned atomic operation may incur "
+ "significant performance penalty"
+ "; the expected alignment (%0 bytes) exceeds the actual alignment (%1 bytes)">,
+ InGroup<AtomicAlignment>;
+
+def warn_atomic_op_oversized : Warning<
+ "large atomic operation may incur "
+ "significant performance penalty"
+ "; the access size (%0 bytes) exceeds the max lock-free size (%1 bytes)">,
+InGroup<AtomicAlignment>;
def warn_alias_with_section : Warning<
"%select{alias|ifunc}1 will not be in section '%0' but in the same section "
def Reorder : DiagGroup<"reorder", [ReorderCtor, ReorderInitList]>;
def UndeclaredSelector : DiagGroup<"undeclared-selector">;
def ImplicitAtomic : DiagGroup<"implicit-atomic-properties">;
+def AtomicAlignment : DiagGroup<"atomic-alignment">;
def CustomAtomic : DiagGroup<"custom-atomic-properties">;
def AtomicProperties : DiagGroup<"atomic-properties",
[ImplicitAtomic, CustomAtomic]>;
bool Oversized = getContext().toBits(sizeChars) > MaxInlineWidthInBits;
bool Misaligned = (Ptr.getAlignment() % sizeChars) != 0;
bool UseLibcall = Misaligned | Oversized;
+ CharUnits MaxInlineWidth =
+ getContext().toCharUnitsFromBits(MaxInlineWidthInBits);
- if (UseLibcall) {
- CGM.getDiags().Report(E->getBeginLoc(), diag::warn_atomic_op_misaligned)
- << !Oversized;
+ DiagnosticsEngine &Diags = CGM.getDiags();
+
+ if (Misaligned) {
+ Diags.Report(E->getBeginLoc(), diag::warn_atomic_op_misaligned)
+ << (int)sizeChars.getQuantity()
+ << (int)Ptr.getAlignment().getQuantity();
+ }
+
+ if (Oversized) {
+ Diags.Report(E->getBeginLoc(), diag::warn_atomic_op_oversized)
+ << (int)sizeChars.getQuantity() << (int)MaxInlineWidth.getQuantity();
}
llvm::Value *Order = EmitScalarExpr(E->getOrder());
void func(IntPair *p) {
IntPair res;
- __atomic_load(p, &res, 0); // expected-warning {{misaligned atomic operation may incur significant performance penalty}}
- __atomic_store(p, &res, 0); // expected-warning {{misaligned atomic operation may incur significant performance penalty}}
- __atomic_fetch_add((unaligned_int *)p, 1, 2); // expected-warning {{misaligned atomic operation may incur significant performance penalty}}
- __atomic_fetch_sub((unaligned_int *)p, 1, 3); // expected-warning {{misaligned atomic operation may incur significant performance penalty}}
+ __atomic_load(p, &res, 0); // expected-warning {{misaligned atomic operation may incur significant performance penalty; the expected alignment (8 bytes) exceeds the actual alignment (4 bytes)}}
+ __atomic_store(p, &res, 0); // expected-warning {{misaligned atomic operation may incur significant performance penalty; the expected alignment (8 bytes) exceeds the actual alignment (4 bytes)}}
+ __atomic_fetch_add((unaligned_int *)p, 1, 2); // expected-warning {{misaligned atomic operation may incur significant performance penalty; the expected alignment (4 bytes) exceeds the actual alignment (1 bytes)}}
+ __atomic_fetch_sub((unaligned_int *)p, 1, 3); // expected-warning {{misaligned atomic operation may incur significant performance penalty; the expected alignment (4 bytes) exceeds the actual alignment (1 bytes)}}
}
void func1(LongStruct *p) {
__atomic_fetch_add((int *)p, 1, 2);
__atomic_fetch_sub((int *)p, 1, 3);
}
+
+typedef struct {
+ void *a;
+ void *b;
+} Foo;
+
+typedef struct {
+ void *a;
+ void *b;
+ void *c;
+ void *d;
+} __attribute__((aligned(32))) ThirtyTwo;
+
+void braz(Foo *foo, ThirtyTwo *braz) {
+ Foo bar;
+ __atomic_load(foo, &bar, __ATOMIC_RELAXED); // expected-warning {{misaligned atomic operation may incur significant performance penalty; the expected alignment (16 bytes) exceeds the actual alignment (8 bytes)}}
+
+ ThirtyTwo thirtyTwo1;
+ ThirtyTwo thirtyTwo2;
+ __atomic_load(&thirtyTwo1, &thirtyTwo2, __ATOMIC_RELAXED); // expected-warning {{large atomic operation may incur significant performance penalty; the access size (32 bytes) exceeds the max lock-free size (16 bytes)}}
+}