code review 871042: runtime: turn run time errors checks into panics

src/pkg/runtime/slice.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
 #include "type.h"
 #include "malloc.h"
 
 static  int32   debug   = 0;
 
@@ skipping 18 matching lines @@
 
         FLUSH(&ret);
 
         if(debug) {
                 printf("makeslice(%S, %d, %d); ret=",
                         *t->string, nel, cap);
                 ·printslice(ret);
         }
 }
 
-static void
-throwslice(uint32 lb, uint32 hb, uint32 n)
-{
-        prints("slice[");
-        ·printint(lb);
-        prints(":");
-        ·printint(hb);
-        prints("] of [");
-        ·printint(n);
-        prints("] array\n");
-        throw("array slice");
-}
-
 // sliceslice(old []any, lb int, hb int, width int) (ary []any);
 void
 ·sliceslice(Slice old, uint32 lb, uint32 hb, uint32 width, Slice ret)
 {
         if(hb > old.cap || lb > hb) {
                 if(debug) {
                         prints("runtime.sliceslice: old=");
                         ·printslice(old);
                         prints("; lb=");
                         ·printint(lb);
                         prints("; hb=");
                         ·printint(hb);
                         prints("; width=");
                         ·printint(width);
                         prints("\n");
 
                         prints("oldarray: nel=");
                         ·printint(old.len);
                         prints("; cap=");
                         ·printint(old.cap);
                         prints("\n");
                 }
-                throwslice(lb, hb, old.cap);
+                ·panicslice();
         }
 
         // new array is inside old array
         ret.len = hb - lb;
         ret.cap = old.cap - lb;
         ret.array = old.array + lb*width;
 
         FLUSH(&ret);
 
         if(debug) {
@@ skipping 24 matching lines @@
                         prints("; width=");
                         ·printint(width);
                         prints("\n");
 
                         prints("oldarray: nel=");
                         ·printint(old.len);
                         prints("; cap=");
                         ·printint(old.cap);
                         prints("\n");
                 }
-                throwslice(lb, old.len, old.cap);
+                ·panicslice();
         }
 
         // new array is inside old array
         ret.len = old.len - lb;
         ret.cap = old.cap - lb;
         ret.array = old.array + lb*width;
 
         FLUSH(&ret);
 
         if(debug) {
@@ skipping 28 matching lines @@
                         prints("; nel=");
                         ·printint(nel);
                         prints("; lb=");
                         ·printint(lb);
                         prints("; hb=");
                         ·printint(hb);
                         prints("; width=");
                         ·printint(width);
                         prints("\n");
                 }
-                throwslice(lb, hb, nel);
+                ·panicslice();
         }
 
         // new array is inside old array
         ret.len = hb-lb;
         ret.cap = nel-lb;
         ret.array = old + lb*width;
 
         FLUSH(&ret);
 
         if(debug) {
@@ skipping 53 matching lines @@
 void
 ·printslice(Slice a)
 {
         prints("[");
         ·printint(a.len);
         prints("/");
         ·printint(a.cap);
         prints("]");
         ·printpointer(a.array);
 }