clang-format

userland/lib/libc/stdlib/exit.c

@@ -34,50 +34,49 @@
  * C standard function: exit process.
  */
 
-void
-exit(int code)
-{
-	/*
-	 * In a more complicated libc, this would call functions registered
-	 * with atexit() before calling the syscall to actually exit.
-	 */
+void exit(int code) {
+  /*
+   * In a more complicated libc, this would call functions registered
+   * with atexit() before calling the syscall to actually exit.
+   */
 
 #ifdef __mips__
-	/*
-	 * Because gcc knows that _exit doesn't return, if we call it
-	 * directly it will drop any code that follows it. This means
-	 * that if _exit *does* return, as happens before it's
-	 * implemented, undefined and usually weird behavior ensues.
-	 *
-	 * As a hack (this is quite gross) do the call by hand in an
-	 * asm block. Then gcc doesn't know what it is, and won't
-	 * optimize the following code out, and we can make sure
-	 * that exit() at least really does not return.
-	 *
-	 * This asm block violates gcc's asm rules by destroying a
-	 * register it doesn't declare ($4, which is a0) but this
-	 * hopefully doesn't matter as the only local it can lose
-	 * track of is "code" and we don't use it afterwards.
-	 */
-	__asm volatile("jal _exit;"	/* call _exit */
-		       "move $4, %0"	/* put code in a0 (delay slot) */
-		       :		/* no outputs */
-		       : "r" (code));	/* code is an input */
-	/*
-	 * Ok, exiting doesn't work; see if we can get our process
-	 * killed by making an illegal memory access. Use a magic
-	 * number address so the symptoms are recognizable and
-	 * unlikely to occur by accident otherwise.
-	 */
-	__asm volatile("li $2, 0xeeeee00f;"	/* load magic addr into v0 */
-		       "lw $2, 0($2)"		/* fetch from it */
-		       :: );			/* no args */
+  /*
+   * Because gcc knows that _exit doesn't return, if we call it
+   * directly it will drop any code that follows it. This means
+   * that if _exit *does* return, as happens before it's
+   * implemented, undefined and usually weird behavior ensues.
+   *
+   * As a hack (this is quite gross) do the call by hand in an
+   * asm block. Then gcc doesn't know what it is, and won't
+   * optimize the following code out, and we can make sure
+   * that exit() at least really does not return.
+   *
+   * This asm block violates gcc's asm rules by destroying a
+   * register it doesn't declare ($4, which is a0) but this
+   * hopefully doesn't matter as the only local it can lose
+   * track of is "code" and we don't use it afterwards.
+   */
+  __asm volatile("jal _exit;"  /* call _exit */
+                 "move $4, %0" /* put code in a0 (delay slot) */
+                 :             /* no outputs */
+                 : "r"(code)); /* code is an input */
+  /*
+   * Ok, exiting doesn't work; see if we can get our process
+   * killed by making an illegal memory access. Use a magic
+   * number address so the symptoms are recognizable and
+   * unlikely to occur by accident otherwise.
+   */
+  __asm volatile("li $2, 0xeeeee00f;" /* load magic addr into v0 */
+                 "lw $2, 0($2)"       /* fetch from it */
+                 ::);                 /* no args */
 #else
-	_exit(code);
+  _exit(code);
 #endif
-	/*
-	 * We can't return; so if we can't exit, the only other choice
-	 * is to loop.
-	 */
-	while (1) { }
+  /*
+   * We can't return; so if we can't exit, the only other choice
+   * is to loop.
+   */
+  while (1) {
+  }
 }