@@ -639,23 +639,30 @@ impl<T> Vec<T> {
639
639
#[ inline]
640
640
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
641
641
pub fn push ( & mut self , value : T ) {
642
+ #[ cold]
643
+ #[ inline( never) ]
644
+ fn resize < T > ( vec : & mut Vec < T > ) {
645
+ let old_size = vec. cap * mem:: size_of :: < T > ( ) ;
646
+ let size = max ( old_size, 2 * mem:: size_of :: < T > ( ) ) * 2 ;
647
+ if old_size > size { panic ! ( "capacity overflow" ) }
648
+ unsafe {
649
+ let ptr = alloc_or_realloc ( * vec. ptr , old_size, size) ;
650
+ if ptr. is_null ( ) { :: alloc:: oom ( ) }
651
+ vec. ptr = Unique :: new ( ptr) ;
652
+ }
653
+ vec. cap = max ( vec. cap , 2 ) * 2 ;
654
+ }
655
+
642
656
if mem:: size_of :: < T > ( ) == 0 {
643
657
// zero-size types consume no memory, so we can't rely on the
644
658
// address space running out
645
659
self . len = self . len . checked_add ( 1 ) . expect ( "length overflow" ) ;
646
660
unsafe { mem:: forget ( value) ; }
647
661
return
648
662
}
663
+
649
664
if self . len == self . cap {
650
- let old_size = self . cap * mem:: size_of :: < T > ( ) ;
651
- let size = max ( old_size, 2 * mem:: size_of :: < T > ( ) ) * 2 ;
652
- if old_size > size { panic ! ( "capacity overflow" ) }
653
- unsafe {
654
- let ptr = alloc_or_realloc ( * self . ptr , old_size, size) ;
655
- if ptr. is_null ( ) { :: alloc:: oom ( ) }
656
- self . ptr = Unique :: new ( ptr) ;
657
- }
658
- self . cap = max ( self . cap , 2 ) * 2 ;
665
+ resize ( self ) ;
659
666
}
660
667
661
668
unsafe {
0 commit comments