Add readme about new features and improve comments

Author: rwxe

README.md

@@ -2,19 +2,19 @@
 # overflow
 Check for integer overflow in Golang arithmetic and type conversion.
 ### Install
-```
+```sh
 go get github.com/johncgriffin/overflow
 ```
 Note that because Go has no template types, the majority of repetitive code is 
 generated by overflow_template.sh.  If you have to change an
 algorithm, change it there and regenerate the Go code via:
-```
+```sh
 go generate
 ```
 ### Synopsis
 
 #### Arithmetic overflow detection
-```
+```go
 package main
 
 import "fmt"
@@ -34,7 +34,7 @@ func main() {
 }
 ```
 yields the output
-```
+```go
 9223372036854775802+0 -> (9223372036854775802,true)
 9223372036854775802+1 -> (9223372036854775803,true)
 9223372036854775802+2 -> (9223372036854775804,true)
@@ -51,7 +51,7 @@ For (u)int types, provide (U)Add, (U)Sub, (U)Mul, (U)Div, (U)Quotient, etc.
 
 
 #### Type conversion overflow detection
-```
+```go
 func main() {
 	var i uint
 	for i = math.MaxInt - 5; i <= math.MaxInt+5; i++ {
@@ -62,7 +62,7 @@ func main() {
 }
 ```
 yields the output
-```
+```go
 9223372036854775802 -> (9223372036854775802,true)
 9223372036854775803 -> (9223372036854775803,true)
 9223372036854775804 -> (9223372036854775804,true)
@@ -83,6 +83,22 @@ There's a good case to be made that a panic is an unidiomatic but proper respons
 believe that there's no valid way to continue your program after math goes wayward, you can
 use the easier Addp, Mulp, Subp, and Divp versions which return the normal result or panic.
 
+### Performance considerations
+
+Compared with the integer type safety libraries of other languages (such as C++), this
+library uses some seemingly slow operations, such as division. But this does not mean that
+these methods will be slow, on the contrary, it will be faster than complex implementations
+in other languages. The reason is that Go does not allow forced inlining, and any complex
+functions will be abandoned for inlining, resulting in additional calling overhead. Short
+functions are lightning fast due to automatic inlining. For example, for unsigned 64-bit
+integer multiplication overflow detection, when inlining is disabled, division takes five
+times as long as long multiplication, but after automatic inlining is allowed, division
+takes 1/5 of long multiplication.
+
+Note that using `//go:noinline` in your business function will not affect the inlining of
+the library function. Only disabling global inlining through `-gcflags="-l"` will affect the
+inlining of this library function.
+
 
 - - -
 MIT License