Expose cache line size in __builtin_get_cpu_cache_line_size

[zoecarver]

Summary

This patch creates the __builtin_get_cpu_cache_line_size to wrap the cpu cache line size API from D74918.

[craig.topper]

What should the behavior of the builtin be if the calling function has its own target cpu like attribute((target("arch=sandybridge"))) and that CPU has a different size than the CPU that was passed on the command line?

clang/include/clang/Basic/Builtins.def

1483

Can this be "zv" and drop the "tu" from the second string?

[zoecarver]

@craig.topper thanks for the comments! I'm going to hold off on updating this until we figure out what's happening with D74918, though.

[jyknight]

I don't think there's a particularly good reason to expose this as a builtin, unless it's to be used by the standard library implementation. (Which again I do not think we should implement.)

[zoecarver]

@jyknight yes, the current plan is to use it in libc++'s implementation. I can put that implementation (which uses this builtin) up for review before this lands. That way we can discuss the implementation before adding a (possibly unneeded) builtin. Sound good?

[zoecarver]

• Fix based on review comments

[zoecarver]

@craig.topper I'm not sure what should happen. It should probably just use that CPU (although that's not a great solution). Is there a way to detect if an attribute was used to change the target in which case we could error? What do you think should happen?

[zoecarver]

• Diff from master

[craig.topper]

In D76525#1942825, @zoecarver wrote:

@craig.topper I'm not sure what should happen. It should probably just use that CPU (although that's not a great solution). Is there a way to detect if an attribute was used to change the target in which case we could error? What do you think should happen?

I'm not sure what should happen as I'm not familiar with the library feature being implemented. As implemented here, the target attribute will be ignored and it will just follow the command line. Why do you say that following the attribute is not a great solution?

clang/test/SemaCXX/builtin-cache-line-size.cpp

1

This say i368 which is not a valid cpu. Did you mean i386? Also x86 uses use -march not -mcpu. I don't think -mcpu does anything.

clang/include/clang/Basic/Builtins.def

 
 // Clang builtins (not available in GCC).
 BUILTIN(__builtin_addressof, "v*v&", "nct")
 BUILTIN(__builtin_operator_new, "v*z", "tc")
 BUILTIN(__builtin_operator_delete, "vv*", "tn")
 BUILTIN(__builtin_char_memchr, "c*cC*iz", "n")
 BUILTIN(__builtin_dump_struct, "ivC*v*", "tn")
 BUILTIN(__builtin_preserve_access_index, "v.", "t")
+BUILTIN(__builtin_get_cpu_cache_line_size, "zv", "nc")
 
 // Alignment builtins (uses custom parsing to support pointers and integers)
 BUILTIN(__builtin_is_aligned, "bvC*z", "nct")
 BUILTIN(__builtin_align_up, "v*vC*z", "nct")
 BUILTIN(__builtin_align_down, "v*vC*z", "nct")
 
 // Safestack builtins
 BUILTIN(__builtin___get_unsafe_stack_start, "v*", "Fn")

clang/lib/AST/ExprConstant.cpp

if (Info.InConstantContext && !Info.CheckingPotentialConstantExpression &&
                     diag::warn_is_constant_evaluated_always_true_constexpr)
             << (Info.CallStackDepth == 1 ? "__builtin_is_constant_evaluated"
                                          : "std::is_constant_evaluated");
     }
 
     return Success(Info.InConstantContext, E);
   }
 
+  case Builtin::BI__builtin_get_cpu_cache_line_size: {
+    Optional<unsigned> cacheLineSize =
+      Info.Ctx.getTargetInfo().getCPUCacheLineSize();
+    if (cacheLineSize.hasValue())
+      return Success(cacheLineSize.getValue(), E);
+    return Success(0, E);
+  }
+
   case Builtin::BI__builtin_ctz:
   case Builtin::BI__builtin_ctzl:
   case Builtin::BI__builtin_ctzll:
   case Builtin::BI__builtin_ctzs: {
     APSInt Val;
     if (!EvaluateInteger(E->getArg(0), Val, Info))
       return false;
     if (!Val)

clang/test/SemaCXX/builtin-cache-line-size.cpp

+// RUN: %clang -mcpu=i368 %s
+// RUN: ./a.out
+
+#include <cassert>
+
+size_t a() {
+  return __builtin_get_cpu_cache_line_size();
+}
+
+size_t b(bool x) {
+  if (x) {
+    return __builtin_get_cpu_cache_line_size();
+  }
+  return 0;
+}
+
+int main() {
+  assert(a() == 64);
+  assert(b(true) == 64);
+  assert(b(false) == 0);
+}
+
+// This is based on the value for i368.
+static_assert(__builtin_get_cpu_cache_line_size() == 64, "");
+
+struct keep_apart {
+  alignas(__builtin_get_cpu_cache_line_size()) int cat;
+  alignas(__builtin_get_cpu_cache_line_size()) int dog;
+};
+
+static_assert(sizeof(keep_apart) == __builtin_get_cpu_cache_line_size() * 2 ||
+              __builtin_get_cpu_cache_line_size() == 0, "");