libvpx: Pull from upstream

source/libvpx/vp9/common/arm/neon/vp9_reconintra_neon.asm

 ;
 ;  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
 ;
 ;  Use of this source code is governed by a BSD-style license
 ;  that can be found in the LICENSE file in the root of the source
 ;  tree. An additional intellectual property rights grant can be found
 ;  in the file PATENTS.  All contributing project authors may
 ;  be found in the AUTHORS file in the root of the source tree.
 ;
 
@@ skipping 331 matching lines @@
 ; r2  const uint8_t *above
 ; r3  const uint8_t *left
 
 |vp9_tm_predictor_8x8_neon| PROC
     ; Load ytop_left = above[-1];
     sub                 r12, r2, #1
     ldrb                r12, [r12]
     vdup.u8             d0, r12
 
     ; preload 8 left
-    vld1.8              d30, [r3]
+    vld1.8              {d30}, [r3]
 
     ; Load above 8 pixels
     vld1.64             {d2}, [r2]
 
     vmovl.u8            q10, d30
 
     ; Compute above - ytop_left
     vsubl.u8            q3, d2, d0
 
     ; Load left row by row and compute left + (above - ytop_left)
@@ skipping 52 matching lines @@
 ; r2  const uint8_t *above
 ; r3  const uint8_t *left
 
 |vp9_tm_predictor_16x16_neon| PROC
     ; Load ytop_left = above[-1];
     sub                 r12, r2, #1
     ldrb                r12, [r12]
     vdup.u8             q0, r12
 
     ; Load above 8 pixels
-    vld1.8              q1, [r2]
+    vld1.8              {q1}, [r2]
 
     ; preload 8 left into r12
-    vld1.8              d18, [r3]!
+    vld1.8              {d18}, [r3]!
 
     ; Compute above - ytop_left
     vsubl.u8            q2, d2, d0
     vsubl.u8            q3, d3, d1
 
     vmovl.u8            q10, d18
 
     ; Load left row by row and compute left + (above - ytop_left)
     ; Process 8 rows in each single loop and loop 2 times to process 16 rows.
     mov                 r2, #2
@@ skipping 46 matching lines @@
     vadd.s16            q1, q0, q2
     vadd.s16            q0, q0, q3
     vadd.s16            q11, q8, q2
     vadd.s16            q8, q8, q3
     vqshrun.s16         d2, q1, #0
     vqshrun.s16         d3, q0, #0
     vqshrun.s16         d22, q11, #0
     vqshrun.s16         d23, q8, #0
     vdup.16             q0, d20[2]
     vdup.16             q8, d20[3]
-    vld1.8              d18, [r3]!                  ; preload 8 left into r12
+    vld1.8              {d18}, [r3]!                  ; preload 8 left into r12
     vmovl.u8            q10, d18
     vst1.64             {d2,d3}, [r0], r1
     vst1.64             {d22,d23}, [r0], r1
 
     subs                r2, r2, #1
     bgt                 loop_16x16_neon
 
     bx                  lr
     ENDP                ; |vp9_tm_predictor_16x16_neon|
 
 ;void vp9_tm_predictor_32x32_neon (uint8_t *dst, ptrdiff_t y_stride,
 ;                                  const uint8_t *above,
 ;                                  const uint8_t *left)
 ; r0  uint8_t *dst
 ; r1  ptrdiff_t y_stride
 ; r2  const uint8_t *above
 ; r3  const uint8_t *left
 
 |vp9_tm_predictor_32x32_neon| PROC
     ; Load ytop_left = above[-1];
     sub                 r12, r2, #1
     ldrb                r12, [r12]
     vdup.u8             q0, r12
 
     ; Load above 32 pixels
-    vld1.8              q1, [r2]!
-    vld1.8              q2, [r2]
+    vld1.8              {q1}, [r2]!
+    vld1.8              {q2}, [r2]
 
     ; preload 8 left pixels
-    vld1.8              d26, [r3]!
+    vld1.8              {d26}, [r3]!
 
     ; Compute above - ytop_left
     vsubl.u8            q8, d2, d0
     vsubl.u8            q9, d3, d1
     vsubl.u8            q10, d4, d0
     vsubl.u8            q11, d5, d1
 
     vmovl.u8            q3, d26
 
     ; Load left row by row and compute left + (above - ytop_left)
@@ skipping 78 matching lines @@
     vqshrun.s16         d1, q13, #0
     vadd.s16            q12, q2, q8
     vadd.s16            q13, q2, q9
     vqshrun.s16         d2, q14, #0
     vqshrun.s16         d3, q15, #0
     vadd.s16            q14, q2, q10
     vadd.s16            q15, q2, q11
     vst1.64             {d0-d3}, [r0], r1
     vqshrun.s16         d24, q12, #0
     vqshrun.s16         d25, q13, #0
-    vld1.8              d0, [r3]!                   ; preload 8 left pixels
+    vld1.8              {d0}, [r3]!                   ; preload 8 left pixels
     vqshrun.s16         d26, q14, #0
     vqshrun.s16         d27, q15, #0
     vmovl.u8            q3, d0
     vst1.64             {d24-d27}, [r0], r1
 
     subs                r2, r2, #1
     bgt                 loop_32x32_neon
 
     bx                  lr
     ENDP                ; |vp9_tm_predictor_32x32_neon|
 
     END