1. 05 Aug, 2020 1 commit
    • Jakob Gruber's avatar
      [nci] Replace CompilationTarget with a new Code::Kind value · c51041f4
      Jakob Gruber authored
      With the new Turbofan variants (NCI and Turboprop), we need a way to
      distinguish between them both during and after compilation. We
      initially introduced CompilationTarget to track the variant during
      compilation, but decided to reuse the code kind as the canonical spot to
      store this information instead.
      
      Why? Because it is an established mechanism, already available in most
      of the necessary spots (inside the pipeline, on Code objects, in
      profiling traces).
      
      This CL removes CompilationTarget and adds a new
      NATIVE_CONTEXT_INDEPENDENT kind, plus helper functions to determine
      various things about a given code kind (e.g.: does this code kind
      deopt?).
      
      As a (very large) drive-by, refactor both Code::Kind and
      AbstractCode::Kind into a new CodeKind enum class.
      
      Bug: v8:8888
      Change-Id: Ie858b9a53311b0731630be35cf5cd108dee95b39
      Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2336793
      Commit-Queue: Jakob Gruber <jgruber@chromium.org>
      Reviewed-by: 's avatarClemens Backes <clemensb@chromium.org>
      Reviewed-by: 's avatarRoss McIlroy <rmcilroy@chromium.org>
      Reviewed-by: 's avatarDominik Inführ <dinfuehr@chromium.org>
      Reviewed-by: 's avatarGeorg Neis <neis@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#69244}
      c51041f4
  2. 19 Mar, 2020 1 commit
  3. 17 Mar, 2020 1 commit
  4. 27 Feb, 2020 2 commits
    • Milad Farazmand's avatar
      PPC/s390: [wasm] Save FP & PC when calling C functions · 242d58e3
      Milad Farazmand authored
      Port 6cd28b52
      
      Original Commit Message:
      
          Added implementations for ia32, arm, arm64.
      
          mips/mips64 will be committed in separate CL once the build is green
          again in order not to stall this CL with the supported architectures.
      
          compilation by using alternative temp register for x64.
      
          macro assemblers.
      
      R=ecmziegler@chromium.org, joransiu@ca.ibm.com, jyan@ca.ibm.com, michael_dawson@ca.ibm.com
      BUG=
      LOG=N
      
      Change-Id: Ib08e31dfa11f0254c7888ce17dd27e7d0154c752
      Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2078898Reviewed-by: 's avatarJunliang Yan <jyan@ca.ibm.com>
      Commit-Queue: Milad Farazmand <miladfar@ca.ibm.com>
      Cr-Commit-Position: refs/heads/master@{#66490}
      242d58e3
    • Emanuel Ziegler's avatar
      [wasm] Save FP & PC when calling C functions · 6cd28b52
      Emanuel Ziegler authored
      Added implementations for ia32, arm, arm64.
      
      mips/mips64 will be committed in separate CL once the build is green
      again in order not to stall this CL with the supported architectures.
      
      Drive-by: Fixed issues with kScratchRegister being overwritten in case of RegExp
      compilation by using alternative temp register for x64.
      
      Drive-by: Added missing NoRootArrayScope to ia32, arm and arm64 RegExp
      macro assemblers.
      
      R=clemensb@chromium.org
      R=petermarshall@chromium.org
      R=jgruber@chromium.org
      
      Bug: chromium:1045860
      Change-Id: I716d852b9bf780ae7b8d61376c6505dd3af96a50
      Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2071866
      Commit-Queue: Emanuel Ziegler <ecmziegler@chromium.org>
      Reviewed-by: 's avatarJakob Gruber <jgruber@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#66482}
      6cd28b52
  5. 14 Nov, 2019 1 commit
  6. 28 May, 2019 1 commit
  7. 23 May, 2019 1 commit
  8. 22 May, 2019 1 commit
  9. 21 May, 2019 1 commit
  10. 02 May, 2019 1 commit
    • Pierre Langlois's avatar
      [arm][arm64] Do not allocate temp registers for the write barrier. · 3f1a59f4
      Pierre Langlois authored
      Improve code generation for stores with write barriers slightly by using the
      assembler's dedicated scratch registers (x16 and x17 on Arm64, ip on Arm)
      instead of allocating temporaries.
      
      To do this, we've done two things:
      
        - Use ip as a scratch register when loading page flags.
      
        - TurboAssembler::CallRecordWriteStub() now takes the offset of the slot
          that's written to rather than its address, removing the need to allocate a
          temporary register for it.
      
      In essence, we've gone from:
      
      ```
      ;; Do the store.
      stur x19, [x9, #15]
      ;; Check *destination* object page flags and jump out-of-line.
      and x4, x9, #0xfffffffffff80000
      ldr x4, [x4, #8]
      tbnz x4, #2, #+0x1e7c
      |     ;; Check *source* object page flags.
      | `-> and x4, x19, #0xfffffffffff80000
      |     ldr x4, [xM, #8]
      |,--- tbz x4, #1, #-0x1e80
      |     ;; Compute address of slot.
      |     add x5, x9, #0xf (15)
      |     ;; Setup arguments to RecordWrite
      |     stp x2, x3, [sp, #-32]!
      |     stp x4, lr, [sp, #16]
      |     stp x0, x1, [sp, #-16]!
      |     mov x0, x9 ;; Object address in x9
      |     mov x1, x5 ;; Slot address in x5
      |     movz x2, #0x0
      |     movz x3, #0x100000000
      |     ;; Call RecordWrite
      |     ldr x16, pc+2056
      |     blr x16
      ```
      
      Which allocates x4 and x5 as temporaries.
      
      To:
      
      ```
      stur x19, [x9, #15]
      and x16, x9, #0xfffffffffff80000 ;; Using x16 instead of allocating x4.
      ldr x16, [x16, #8]
      tbnz x16, #2, #+0x1e7c
      | `-> and x16, x19, #0xfffffffffff80000
      |     ldr x16, [xM, #8]
      |,--- tbz x16, #1, #-0x1e80
      |     stp x2, x3, [sp, #-32]!
      |     stp x4, lr, [sp, #16]
      |     stp x0, x1, [sp, #-16]!
      |     mov x0, x9            ;; Object address still in x9.
      |     add x1, x9, #0xf (15) ;; Compute the slot address directly.
      |     movz x2, #0x0
      |     movz x3, #0x100000000
      |     ldr x16, pc+2056
      |     blr x16
      ```
      
      Finally, `RecordWriteField()` does not need an extra scratch register anymore.
      
      Change-Id: Icb71310e7b8ab1ca83ced250851456166b337d00
      Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1505793
      Commit-Queue: Pierre Langlois <pierre.langlois@arm.com>
      Reviewed-by: 's avatarSigurd Schneider <sigurds@chromium.org>
      Reviewed-by: 's avatarUlan Degenbaev <ulan@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#61153}
      3f1a59f4
  11. 06 Mar, 2019 1 commit
  12. 17 Jan, 2019 2 commits
  13. 03 Oct, 2018 1 commit
  14. 08 Aug, 2018 1 commit
    • Junliang Yan's avatar
      PPC/s390: Reland "[turboassembler] Introduce hard-abort mode" · a27871d5
      Junliang Yan authored
      Port d324382e
      
      and
      
      Port bd3f0a68
      
      Original Commit Message:
      
          This is a reland of a462a785
      
          Original change's description:
          > [turboassembler] Introduce hard-abort mode
          >
          > For checks and assertions (mostly for debug code, like stack alignment
          > or zero extension), we had two modes: Emit a call to the {Abort}
          > runtime function (the default), and emit a debug break (used for
          > testing, enabled via --trap-on-abort).
          > In wasm, where we cannot just call a runtime function because code must
          > be isolate independent, we always used the trap-on-abort behaviour.
          > This causes problems for our fuzzers, which do not catch SIGTRAP, and
          > hence do not detect debug code failures.
          >
          > This CL introduces a third mode ("hard abort"), which calls a C
          > function via {ExternalReference}. The C function still outputs the
          > abort reason, but does not print the stack trace. It then aborts via
          > "OS::Abort", just like the runtime function.
          > This will allow fuzzers to detect the crash and even find a nice error
          > message.
          >
          > Even though this looks like a lot of code churn, it is actually not.
          > Most added lines are new tests, and other changes are minimal.
          >
          > R=mstarzinger@chromium.org
          >
          > Bug: chromium:863799
          > Change-Id: I77c58ff72db552d49014614436259ccfb49ba87b
          > Reviewed-on: https://chromium-review.googlesource.com/1142163
          > Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
          > Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
          > Cr-Commit-Position: refs/heads/master@{#54592}
      
      R=clemensh@chromium.org, joransiu@ca.ibm.com, michael_dawson@ca.ibm.com
      BUG=
      LOG=N
      
      Change-Id: I60023470fa07576fd313f628ade06e279d5f4927
      Reviewed-on: https://chromium-review.googlesource.com/1165822
      Commit-Queue: Junliang Yan <jyan@ca.ibm.com>
      Reviewed-by: 's avatarClemens Hammacher <clemensh@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54980}
      a27871d5
  15. 01 Aug, 2018 1 commit
  16. 24 Jul, 2018 1 commit
    • Clemens Hammacher's avatar
      Reland "[turboassembler] Introduce hard-abort mode" · d324382e
      Clemens Hammacher authored
      This is a reland of a462a785
      
      Original change's description:
      > [turboassembler] Introduce hard-abort mode
      > 
      > For checks and assertions (mostly for debug code, like stack alignment
      > or zero extension), we had two modes: Emit a call to the {Abort}
      > runtime function (the default), and emit a debug break (used for
      > testing, enabled via --trap-on-abort).
      > In wasm, where we cannot just call a runtime function because code must
      > be isolate independent, we always used the trap-on-abort behaviour.
      > This causes problems for our fuzzers, which do not catch SIGTRAP, and
      > hence do not detect debug code failures.
      > 
      > This CL introduces a third mode ("hard abort"), which calls a C
      > function via {ExternalReference}. The C function still outputs the
      > abort reason, but does not print the stack trace. It then aborts via
      > "OS::Abort", just like the runtime function.
      > This will allow fuzzers to detect the crash and even find a nice error
      > message.
      > 
      > Even though this looks like a lot of code churn, it is actually not.
      > Most added lines are new tests, and other changes are minimal.
      > 
      > R=mstarzinger@chromium.org
      > 
      > Bug: chromium:863799
      > Change-Id: I77c58ff72db552d49014614436259ccfb49ba87b
      > Reviewed-on: https://chromium-review.googlesource.com/1142163
      > Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
      > Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
      > Cr-Commit-Position: refs/heads/master@{#54592}
      
      Bug: chromium:863799
      Change-Id: I7729a47b4823a982a8e201df36520aa2b6ef5326
      Reviewed-on: https://chromium-review.googlesource.com/1146100Reviewed-by: 's avatarMichael Starzinger <mstarzinger@chromium.org>
      Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54656}
      d324382e
  17. 20 Jul, 2018 2 commits
    • Sigurd Schneider's avatar
      Speculatively revert "[turboassembler] Introduce hard-abort mode" · 039c18e1
      Sigurd Schneider authored
      This reverts commit a462a785.
      
      Reason for revert: Breaks a TurboAssembler test:
      https://ci.chromium.org/p/v8/builders/luci.v8.ci/V8%20Arm/7726
      
      Original change's description:
      > [turboassembler] Introduce hard-abort mode
      > 
      > For checks and assertions (mostly for debug code, like stack alignment
      > or zero extension), we had two modes: Emit a call to the {Abort}
      > runtime function (the default), and emit a debug break (used for
      > testing, enabled via --trap-on-abort).
      > In wasm, where we cannot just call a runtime function because code must
      > be isolate independent, we always used the trap-on-abort behaviour.
      > This causes problems for our fuzzers, which do not catch SIGTRAP, and
      > hence do not detect debug code failures.
      > 
      > This CL introduces a third mode ("hard abort"), which calls a C
      > function via {ExternalReference}. The C function still outputs the
      > abort reason, but does not print the stack trace. It then aborts via
      > "OS::Abort", just like the runtime function.
      > This will allow fuzzers to detect the crash and even find a nice error
      > message.
      > 
      > Even though this looks like a lot of code churn, it is actually not.
      > Most added lines are new tests, and other changes are minimal.
      > 
      > R=​mstarzinger@chromium.org
      > 
      > Bug: chromium:863799
      > Change-Id: I77c58ff72db552d49014614436259ccfb49ba87b
      > Reviewed-on: https://chromium-review.googlesource.com/1142163
      > Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
      > Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
      > Cr-Commit-Position: refs/heads/master@{#54592}
      
      TBR=mstarzinger@chromium.org,clemensh@chromium.org
      
      Change-Id: I60c011cfe262ccebbb9abf32699a9fe17e72a3c8
      No-Presubmit: true
      No-Tree-Checks: true
      No-Try: true
      Bug: chromium:863799
      Reviewed-on: https://chromium-review.googlesource.com/1145431
      Commit-Queue: Sigurd Schneider <sigurds@chromium.org>
      Reviewed-by: 's avatarSigurd Schneider <sigurds@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54597}
      039c18e1
    • Clemens Hammacher's avatar
      [turboassembler] Introduce hard-abort mode · a462a785
      Clemens Hammacher authored
      For checks and assertions (mostly for debug code, like stack alignment
      or zero extension), we had two modes: Emit a call to the {Abort}
      runtime function (the default), and emit a debug break (used for
      testing, enabled via --trap-on-abort).
      In wasm, where we cannot just call a runtime function because code must
      be isolate independent, we always used the trap-on-abort behaviour.
      This causes problems for our fuzzers, which do not catch SIGTRAP, and
      hence do not detect debug code failures.
      
      This CL introduces a third mode ("hard abort"), which calls a C
      function via {ExternalReference}. The C function still outputs the
      abort reason, but does not print the stack trace. It then aborts via
      "OS::Abort", just like the runtime function.
      This will allow fuzzers to detect the crash and even find a nice error
      message.
      
      Even though this looks like a lot of code churn, it is actually not.
      Most added lines are new tests, and other changes are minimal.
      
      R=mstarzinger@chromium.org
      
      Bug: chromium:863799
      Change-Id: I77c58ff72db552d49014614436259ccfb49ba87b
      Reviewed-on: https://chromium-review.googlesource.com/1142163
      Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
      Reviewed-by: 's avatarMichael Starzinger <mstarzinger@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54592}
      a462a785