Size and element numbers are often swapped when calling calloc

[MaskRay]

This is an unnecessary change. The arguments are interchangeable.
In musl, there are at least 2 places where the parameters could be swapped, but I not unsure this warrants a commit.

[vzakhari]

In D148958#4288728, @MaskRay wrote:

This is an unnecessary change. The arguments are interchangeable.
In musl, there are at least 2 places where the parameters could be swapped, but I not unsure this warrants a commit.

Isn't the memory alignment dependent on the element size in general? In this case it might be a potential correctness issue fix.
I understand that many calloc implementations may align them to works-for-all boundary, but it may still worth be "fixing".

[MaskRay]

In D148958#4288782, @vzakhari wrote:

In D148958#4288728, @MaskRay wrote:

This is an unnecessary change. The arguments are interchangeable.
In musl, there are at least 2 places where the parameters could be swapped, but I not unsure this warrants a commit.

Isn't the memory alignment dependent on the element size in general? In this case it might be a potential correctness issue fix.
I understand that many calloc implementations may align them to works-for-all boundary, but it may still worth be "fixing".

No. The two arguments are interchangeable. Neither argument affects the alignment. Use aligned_alloc to control alignment.

clang/test/Analysis/malloc.mm

 
 void testUseAfterFree() {
   int *p = (int *)malloc(sizeof(int));
   free(p);
   [My param:p];  // expected-warning{{Use of memory after it is freed}}
 }
 
 void testNoCopy() {
-  char *p = (char *)calloc(sizeof(int), 1);
+  char *p = (char *)calloc(1, sizeof(int));
   CustomData *w = [CustomData somethingNoCopy:p]; // no-warning
 }
 
 void testFreeWhenDone() {
-  char *p = (char *)calloc(sizeof(int), 1);
+  char *p = (char *)calloc(1, sizeof(int));
   CustomData *w = [CustomData something:p freeWhenDone:1]; // no-warning
 }
 
 void testFreeWhenDonePositive() {
-  char *p = (char *)calloc(sizeof(int), 1);
+  char *p = (char *)calloc(1, sizeof(int));
   CustomData *w = [CustomData something:p freeWhenDone:0]; // expected-warning{{leak}}
 }
 
 void testFreeWhenDoneNoCopy() {
   int *p = (int *)malloc(sizeof(int));
   CustomData *w = [CustomData somethingNoCopy:p length:sizeof(int) freeWhenDone:1]; // no-warning
 }
 

clang/test/Analysis/uninit-vals.m

Point makePoint(float x, float y) {
   Point result;
   result.x = x;
   result.y = y;
   result.z = 0.0;
   return result;
 }
 
 void PR14765_test(void) {
-  Circle *testObj = calloc(sizeof(Circle), 1);
+  Circle *testObj = calloc(1, sizeof(Circle));
 
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{TRUE}}
                                            // expected-note@-1{{TRUE}}
 
   testObj->origin = makePoint(0.0, 0.0);
   if (testObj->size > 0) { ; } // expected-note{{Assuming field 'size' is <= 0}}
                                // expected-note@-1{{Taking false branch}}
 
IntPoint makeIntPoint(int x, int y) {
   IntPoint result;
   result.x = x;
   result.y = y;
   result.z = 0;
   return result;
 }
 
 void PR14765_test_int(void) {
-  IntCircle *testObj = calloc(sizeof(IntCircle), 1);
+  IntCircle *testObj = calloc(1, sizeof(IntCircle));
 
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{TRUE}}
                                            // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.x == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.y == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.z == 0); // expected-warning{{TRUE}}
void testLargeStructsNotCopiedPerField(void) {
 
   IntPoint b = a;
   extern void useInt(int);
   useInt(b.x); // no-warning
   useInt(b.y); // no-warning
 }
 
 void testSmallStructInLargerStruct(void) {
-  IntCircle2D *testObj = calloc(sizeof(IntCircle2D), 1);
+  IntCircle2D *testObj = calloc(1, sizeof(IntCircle2D));
 
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{TRUE}}
                                            // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.x == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.y == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
 

clang/test/CodeGen/alloc-size.c

void test5(void) {
   gi = OBJECT_SIZE_BUILTIN(&data->t[1], 0);
   // CHECK: store i32 36
   gi = OBJECT_SIZE_BUILTIN(&data->t[1], 1);
   // CHECK: store i32 40
   gi = OBJECT_SIZE_BUILTIN(&data->t[1], 2);
   // CHECK: store i32 36
   gi = OBJECT_SIZE_BUILTIN(&data->t[1], 3);
 
-  struct Data *const arr = my_calloc(sizeof(*data), 2);
+  struct Data *const arr = my_calloc(2, sizeof(*data));
   // CHECK: store i32 96
   gi = OBJECT_SIZE_BUILTIN(arr, 0);
   // CHECK: store i32 96
   gi = OBJECT_SIZE_BUILTIN(arr, 1);
   // CHECK: store i32 96
   gi = OBJECT_SIZE_BUILTIN(arr, 2);
   // CHECK: store i32 96
   gi = OBJECT_SIZE_BUILTIN(arr, 3);
void test6(void) {
   gi = OBJECT_SIZE_BUILTIN(data->end, 0);
   // CHECK: store i32 11
   gi = OBJECT_SIZE_BUILTIN(data->end, 1);
   // CHECK: store i32 11
   gi = OBJECT_SIZE_BUILTIN(data->end, 2);
   // CHECK: store i32 11
   gi = OBJECT_SIZE_BUILTIN(data->end, 3);
 
-  struct Data *const arr = my_calloc(sizeof(*arr) + 5, 3);
+  struct Data *const arr = my_calloc(3, sizeof(*arr) + 5);
   // AFAICT, GCC treats malloc and calloc identically. So, we should do the
   // same.
   //
   // Additionally, GCC ignores the initial array index when determining whether
   // we're writing off the end of an alloc_size base. e.g.
   //   arr[0].end
   //   arr[1].end
   //   arr[2].end

compiler-rt/lib/profile/InstrProfilingFile.c

 static void initFileWriter(ProfDataWriter *This, FILE *File) {
   This->Write = fileWriter;
   This->WriterCtx = File;
 }
 
 COMPILER_RT_VISIBILITY ProfBufferIO *
 lprofCreateBufferIOInternal(void *File, uint32_t BufferSz) {
   FreeHook = &free;
-  DynamicBufferIOBuffer = (uint8_t *)calloc(BufferSz, 1);
+  DynamicBufferIOBuffer = (uint8_t *)calloc(1, BufferSz);
   VPBufferSize = BufferSz;
   ProfDataWriter *fileWriter =
-      (ProfDataWriter *)calloc(sizeof(ProfDataWriter), 1);
+      (ProfDataWriter *)calloc(1, sizeof(ProfDataWriter));
   initFileWriter(fileWriter, File);
   ProfBufferIO *IO = lprofCreateBufferIO(fileWriter);
   IO->OwnFileWriter = 1;
   return IO;
 }
 
 static void setupIOBuffer(void) {
   const char *BufferSzStr = 0;

compiler-rt/test/tsan/java_finalizer2.cpp

 
 void *Ballast(void *p) {
   Heap* heap = (Heap*)p;
   pthread_barrier_wait(&heap->barrier_ballast);
   return 0;
 }
 
 int main() {
-  Heap* heap = (Heap*)calloc(sizeof(Heap), 2) + 1;
+  Heap* heap = (Heap*)calloc(2, sizeof(Heap)) + 1;
   __tsan_java_init((jptr)heap, sizeof(*heap));
   __tsan_java_alloc((jptr)heap, sizeof(*heap));
   // Ballast threads merely make the bug a bit easier to trigger.
   const int kBallastThreads = 100;
   pthread_barrier_init(&heap->barrier_finalizer, 0, 4);
   pthread_barrier_init(&heap->barrier_ballast, 0, kBallastThreads + 1);
   pthread_t th[3];
   pthread_create(&th[0], 0, Thread1, heap);

flang/runtime/ragged.cpp

for (std::int64_t counter{0}; counter < rank; ++counter) {
       size *= extentVector[counter];
       if (size <= 0) {
         return nullptr;
       }
     }
     header->flags = (rank << 1) | isHeader;
     header->extentPointer = extentVector;
     if (isHeader) {
-      header->bufferPointer = std::calloc(sizeof(RaggedArrayHeader), size);
+      header->bufferPointer = std::calloc(size, sizeof(RaggedArrayHeader));
     } else {
-      header->bufferPointer =
-          static_cast<void *>(std::calloc(elementSize, size));
+      header->bufferPointer = std::calloc(size, elementSize);
     }
     return header;
   } else {
     return nullptr;
   }
 }
 
 // Deallocate a ragged array from the heap.