diff --git a/library/compiler-builtins/libm/src/math/pow.rs b/library/compiler-builtins/libm/src/math/pow.rs
index 69c086b0f242..329b3955d883 100644
--- a/library/compiler-builtins/libm/src/math/pow.rs
+++ b/library/compiler-builtins/libm/src/math/pow.rs
@@ -9,55 +9,54 @@
  * ====================================================
  */
 
-/// pow(x,y) return x**y
-///
-///                    n
-/// Method:  Let x =  2   * (1+f)
-///      1. Compute and return log2(x) in two pieces:
-///              log2(x) = w1 + w2,
-///         where w1 has 53-24 = 29 bit trailing zeros.
-///      2. Perform y*log2(x) = n+y' by simulating muti-precision
-///         arithmetic, where |y'|<=0.5.
-///      3. Return x**y = 2**n*exp(y'*log2)
-///
-/// Special cases:
-///      1.  (anything) ** 0  is 1
-///      2.  1 ** (anything)  is 1
-///      3.  (anything except 1) ** NAN is NAN
-///      4.  NAN ** (anything except 0) is NAN
-///      5.  +-(|x| > 1) **  +INF is +INF
-///      6.  +-(|x| > 1) **  -INF is +0
-///      7.  +-(|x| < 1) **  +INF is +0
-///      8.  +-(|x| < 1) **  -INF is +INF
-///      9.  -1          ** +-INF is 1
-///      10. +0 ** (+anything except 0, NAN)               is +0
-///      11. -0 ** (+anything except 0, NAN, odd integer)  is +0
-///      12. +0 ** (-anything except 0, NAN)               is +INF, raise divbyzero
-///      13. -0 ** (-anything except 0, NAN, odd integer)  is +INF, raise divbyzero
-///      14. -0 ** (+odd integer) is -0
-///      15. -0 ** (-odd integer) is -INF, raise divbyzero
-///      16. +INF ** (+anything except 0,NAN) is +INF
-///      17. +INF ** (-anything except 0,NAN) is +0
-///      18. -INF ** (+odd integer) is -INF
-///      19. -INF ** (anything) = -0 ** (-anything), (anything except odd integer)
-///      20. (anything) ** 1 is (anything)
-///      21. (anything) ** -1 is 1/(anything)
-///      22. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
-///      23. (-anything except 0 and inf) ** (non-integer) is NAN
-///
-/// Accuracy:
-///      pow(x,y) returns x**y nearly rounded. In particular
-///                      pow(integer,integer)
-///      always returns the correct integer provided it is
-///      representable.
-///
-/// Constants :
-/// The hexadecimal values are the intended ones for the following
-/// constants. The decimal values may be used, provided that the
-/// compiler will convert from decimal to binary accurately enough
-/// to produce the hexadecimal values shown.
-///
-
+// pow(x,y) return x**y
+//
+//                    n
+// Method:  Let x =  2   * (1+f)
+//      1. Compute and return log2(x) in two pieces:
+//              log2(x) = w1 + w2,
+//         where w1 has 53-24 = 29 bit trailing zeros.
+//      2. Perform y*log2(x) = n+y' by simulating muti-precision
+//         arithmetic, where |y'|<=0.5.
+//      3. Return x**y = 2**n*exp(y'*log2)
+//
+// Special cases:
+//      1.  (anything) ** 0  is 1
+//      2.  1 ** (anything)  is 1
+//      3.  (anything except 1) ** NAN is NAN
+//      4.  NAN ** (anything except 0) is NAN
+//      5.  +-(|x| > 1) **  +INF is +INF
+//      6.  +-(|x| > 1) **  -INF is +0
+//      7.  +-(|x| < 1) **  +INF is +0
+//      8.  +-(|x| < 1) **  -INF is +INF
+//      9.  -1          ** +-INF is 1
+//      10. +0 ** (+anything except 0, NAN)               is +0
+//      11. -0 ** (+anything except 0, NAN, odd integer)  is +0
+//      12. +0 ** (-anything except 0, NAN)               is +INF, raise divbyzero
+//      13. -0 ** (-anything except 0, NAN, odd integer)  is +INF, raise divbyzero
+//      14. -0 ** (+odd integer) is -0
+//      15. -0 ** (-odd integer) is -INF, raise divbyzero
+//      16. +INF ** (+anything except 0,NAN) is +INF
+//      17. +INF ** (-anything except 0,NAN) is +0
+//      18. -INF ** (+odd integer) is -INF
+//      19. -INF ** (anything) = -0 ** (-anything), (anything except odd integer)
+//      20. (anything) ** 1 is (anything)
+//      21. (anything) ** -1 is 1/(anything)
+//      22. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
+//      23. (-anything except 0 and inf) ** (non-integer) is NAN
+//
+// Accuracy:
+//      pow(x,y) returns x**y nearly rounded. In particular
+//                      pow(integer,integer)
+//      always returns the correct integer provided it is
+//      representable.
+//
+// Constants :
+// The hexadecimal values are the intended ones for the following
+// constants. The decimal values may be used, provided that the
+// compiler will convert from decimal to binary accurately enough
+// to produce the hexadecimal values shown.
+//
 use super::{fabs, get_high_word, scalbn, sqrt, with_set_high_word, with_set_low_word};
 
 const BP: [f64; 2] = [1.0, 1.5];