Follow Rust naming convention for modules and type names

Author: winstonallo

tests/assembly-llvm/reg-struct-return.rs

@@ -22,18 +22,18 @@ use minicore::*;
 
 // Verifies ABI changes for small structs, where both fields fit into one register.
 // WITH is expected to use register return, WITHOUT should use hidden pointer.
-mod small {
-    struct small_t {
+mod Small {
+    struct SmallStruct {
         a: i8,
         b: i8,
     }
 
     unsafe extern "C" {
-        fn small() -> small_t;
+        fn small() -> SmallStruct;
     }
 
     #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn small_callee() -> small_t {
+    pub unsafe extern "C" fn small_callee() -> SmallStruct {
         // (42 << 8) | 42 = 10794
 
         // WITH-LABEL: small_callee
@@ -44,11 +44,11 @@ mod small {
         // WITHOUT-DAG: movl 4(%esp), %e{{.*}}
         // WITHOUT-DAG: movw $10794, (%e{{.*}})
         // WITHOUT: retl $4
-        small_t { a: 42, b: 42 }
+        SmallStruct { a: 42, b: 42 }
     }
 
     #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn small_caller(dst: &mut small_t) {
+    pub unsafe extern "C" fn small_caller(dst: &mut SmallStruct) {
         // WITH-LABEL: small_caller
         // WITH: calll small
         // WITH: movw %ax, (%e{{.*}})
@@ -64,18 +64,18 @@ mod small {
 // for reg-struct-return.
 // WITH is expected to still use register return, WITHOUT should use hidden
 // pointer.
-mod pivot {
-    struct pivot_t {
+mod Pivot {
+    struct PivotStruct {
         a: i32,
         b: i32,
     }
 
     unsafe extern "C" {
-        fn pivot() -> pivot_t;
+        fn pivot() -> PivotStruct;
     }
 
     #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn pivot_callee() -> pivot_t {
+    pub unsafe extern "C" fn pivot_callee() -> PivotStruct {
         // WITH-LABEL: pivot_callee
         // WITH-DAG: movl $42, %e{{.*}}
         // WITH-DAG: movl $42, %e{{.*}}
@@ -86,11 +86,11 @@ mod pivot {
         // WITHOUT-DAG: movl $42, (%e{{.*}})
         // WITHOUT-DAG: movl $42, 4(%e{{.*}})
         // WITHOUT: retl $4
-        pivot_t { a: 42, b: 42 }
+        PivotStruct { a: 42, b: 42 }
     }
 
     #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn pivot_caller(dst: &mut pivot_t) {
+    pub unsafe extern "C" fn pivot_caller(dst: &mut PivotStruct) {
         // WITH-LABEL: pivot_caller
         // WITH: calll pivot
         // WITH-DAG: movl %e{{.*}}, 4(%e{{.*}})
@@ -107,30 +107,30 @@ mod pivot {
 // maximum size for reg-struct-return (8 bytes).
 // Here, both WITH and WITHOUT should use the hidden pointer convention (i.e, they
 // should be identical).
-mod large {
-    struct large_t {
+mod Large {
+    struct LargeStruct {
         a: i32,
         b: i32,
         c: i32,
     }
 
     unsafe extern "C" {
-        fn large() -> large_t;
+        fn large() -> LargeStruct;
     }
 
     #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn large_callee() -> large_t {
+    pub unsafe extern "C" fn large_callee() -> LargeStruct {
         // CHECK-LABEL: large_callee
         // CHECK: movl 4(%esp), %e{{.*}}
         // CHECK-DAG: movl $42, (%e{{.*}})
         // CHECK-DAG: movl $42, 4(%e{{.*}})
         // CHECK-DAG: movl $42, 8(%e{{.*}})
         // CHECK: retl $4
-        large_t { a: 42, b: 42, c: 42 }
+        LargeStruct { a: 42, b: 42, c: 42 }
     }
 
     #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn large_caller(dst: *mut large_t) {
+    pub unsafe extern "C" fn large_caller(dst: *mut LargeStruct) {
         // CHECK-LABEL: large_caller
         // CHECK: calll large
         // CHECK: subl $4, %esp