1. 11 Sep, 2018 1 commit
  2. 10 Sep, 2018 1 commit
    • Tobias Tebbi's avatar
      [torque] disallow using logical operators in value contexts · e569438b
      Tobias Tebbi authored
      This CL makes sure, that logical operators (||, &&) always have return
      type never. Together with a check that never is never passed as a
      function argument, this prevents faulty evaluation as in !(x || y).
      
      Before, the logical operators had a behavior similar to
      (bool labels Taken, NotTaken), with a fast exit if the left-hand side
      allowed shor-circuit evaluation, but returning the right-hand side
      otherwise. Since we want to allow existing (a || b || c) patterns in
      the codebase, this requires weakening the restriction that the left-
      and right-hand side need to have the same type. Now the possibilites
      are:
      bool, never
      never, bool
      never, never
      bool, bool
      constexpr bool, constexpr bool
      
      Bug: v8:8137
      Change-Id: I9576b337dc4008ac58b4625e77fef4e73bcdd6e3
      Reviewed-on: https://chromium-review.googlesource.com/1215162Reviewed-by: 's avatarDaniel Clifford <danno@chromium.org>
      Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#55750}
      e569438b
  3. 13 Aug, 2018 1 commit
  4. 08 Aug, 2018 1 commit
    • Tobias Tebbi's avatar
      [torque] add typeswitch statement · 91ef86f9
      Tobias Tebbi authored
      This adds a typeswitch statement
      
      typeswitch (e)
      case (x1 : Type1) {
        ...
      } case (x2 : Type2) {
      
      } ...
      ... case (xn : TypeN) {
        ...
      }
      
      This checks to which of the given types the result of evaluating e can
      be cast, in the order in which they are listed. So if an earlier
      type matches, a value of this type won't reach a later case.
      
      The type-checks are performed by calling the cast<T>() macro.
      The type of the argument passed to the cast macro is dependent on the
      case and excludes all types checked earlier. For example, in
      
      const x : Object = ...
      typeswitch (x)
      case (x : Smi) {
        ...
      } case (x : HeapNumber) {
        ...
      } case (x : HeapObject) {
        ...
      }
      
      there will be calls to cast<Smi>(Object) and
      cast<HeapNumber>(HeapObject), because after the Smi check we know that
      x has to be a HeapObject. With the refactored base.tq definition of
      cast, this will generate efficient code and avoid repeating the Smi
      check in the second case.
      
      The type system ensures that all cases are reachable and that the type
      given to the last case is safe without a runtime check (in other words,
      the union of all checked types covers the type of e).
      
      The cases can also be written as
      case (Type) { ... }
      , in which case the switched value is not re-bound with the checked
      type.
      
      Bug: v8:7793
      Change-Id: Iea4aed7465d62b445e3ae0d33f52921912e095e3
      Reviewed-on: https://chromium-review.googlesource.com/1156506
      Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
      Reviewed-by: 's avatarDaniel Clifford <danno@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54958}
      91ef86f9
  5. 07 Aug, 2018 1 commit
  6. 03 Aug, 2018 1 commit
  7. 31 Jul, 2018 1 commit
  8. 27 Jul, 2018 2 commits
  9. 17 Jul, 2018 2 commits
    • Daniel Clifford's avatar
      [torque]: Implement structs · 1062ffb9
      Daniel Clifford authored
      Struct are bundles of value types. They are essentially just shorthand
      for passing around a group of individually defined values.
      
      Struct types are declared like this:
      
        struct A {
          x: Smi;
          y: int32;
        }
      
      and can be constructed explicitly like this:
      
        A{0, 0}
      
      Structs can be used wherever other types are used (e.g. variables,
      parameters, return values) except for parameter/return types of
      builtins and runtime functions.
      
      Struct use field access notation to set/get their values like this:
      
        let a: A = A{0, 0};
        let b: Smi = a.x;
        a.y = 0;
      
      Change-Id: I9fd36a6514c37882831256a49a50809c5db75b56
      Reviewed-on: https://chromium-review.googlesource.com/1122133
      Commit-Queue: Daniel Clifford <danno@chromium.org>
      Reviewed-by: 's avatarTobias Tebbi <tebbi@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54501}
      1062ffb9
    • Simon Zünd's avatar
      [torque] Add local const bindings · b95def34
      Simon Zünd authored
      This CL adds local const bindings. This means that instead of
      generating TVARIABLEs for variables, we can generate simple TNodes.
      
      Example:
      
      macro FooBar(): {
        const kSomeSmi: Smi = 10;
        ...
      }
      
      This CL also enforces that variables with a constexpr type are bound
      using 'const' and not 'let'.
      
      R=tebbi@chromium.org
      
      Bug: v8:7793
      Change-Id: Id20a18149df9fc374ce718bdb1478e3eabb6e6df
      Reviewed-on: https://chromium-review.googlesource.com/1138316
      Commit-Queue: Simon Zünd <szuend@google.com>
      Reviewed-by: 's avatarTobias Tebbi <tebbi@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54479}
      b95def34
  10. 13 Jul, 2018 1 commit
  11. 03 Jul, 2018 1 commit
    • Tobias Tebbi's avatar
      [torque] fix variables, returns and conditionals with constexpr · 81186ff4
      Tobias Tebbi authored
      Variables/return values with constexpr type cannot have multiple
      assignments. We check this now.
      For conditionals, it is important to always infer a non-constexpr type.
      This CL adds the ability to map any type (including union types) to be
      mapped to their non-constexpr variant. Conditionals infer their type as
      the non-constexpr version of a combination of the two branch types.
      
      In addition, this improves subtyping for constexpr types:
      If A extends B, then constexpr A extends constexpr B.
      This makes it necessary to clean up "constexpr String", which has nothing
      to do with tagged values.
      
      Bug: v8:7793
      Change-Id: Ia4d3cd5dc98f45b0ec89adf05c5c6111a0e51cc6
      Reviewed-on: https://chromium-review.googlesource.com/1122864
      Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
      Reviewed-by: 's avatarDaniel Clifford <danno@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#54167}
      81186ff4
  12. 28 Jun, 2018 1 commit
  13. 25 Jun, 2018 1 commit
  14. 13 Jun, 2018 1 commit
  15. 12 Jun, 2018 1 commit
    • Daniel Clifford's avatar
      [torque] Turn implicit converts/unsafe_casts into generics · bbbfd81c
      Daniel Clifford authored
      In the process:
        - Add strict ordering of Types so that name mangling is consistent
          and build time. Previously, the UnionType stored the union's
          types in a std::set<const Type*>, which did not have a consistent
          ordering of the types in the set.
        - Add a int31 type to enable consistency and correctness of
          handling of 'constexpr int31' values on the C++ side.
        - By removing the "implicit" keyword for operators, there is now
          one less difference between operators and calls, another
          incremental step in unifying operators and calls.
        - Enable external (i.e. C++-defined) generic specializations
        - Add CSA support for checking double ElementsKinds, including
          tests.
        - Clean up some constexpr/non-constexpr handling of ElementsKinds.
      
      Bug: v8:7793
      Change-Id: I27699aba70b98ebf5466e5b62b045d7b1dad62c8
      Reviewed-on: https://chromium-review.googlesource.com/1091155
      Commit-Queue: Daniel Clifford <danno@chromium.org>
      Reviewed-by: 's avatarTobias Tebbi <tebbi@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#53664}
      bbbfd81c
  16. 05 Jun, 2018 2 commits
  17. 29 May, 2018 1 commit
    • Simon Zünd's avatar
      [torque] Add unsafe cast to Torque. · 9ef4df2f
      Simon Zünd authored
      This CL is a proposal to add "checked" casts (CAST in CSA) to the Torque language.
      The CL adds the "unsafe_cast<>" operator that emits a "CAST".
      
      Example:
      
      let n: Number = ...;
      ...
      if (TaggedIsSmi(n)) {
        let m: Smi = unsafe_cast<Smi>(n);
        ...
      }
      
      The cast wont incur a runtime overhead now.
      
      R=tebbi@chromium.org
      
      Change-Id: I9fca90d1d11e61617ba0270e5022fd66200e2195
      Reviewed-on: https://chromium-review.googlesource.com/1070151
      Commit-Queue: Simon Zünd <szuend@google.com>
      Reviewed-by: 's avatarTobias Tebbi <tebbi@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#53416}
      9ef4df2f
  18. 24 May, 2018 1 commit
  19. 22 May, 2018 2 commits
  20. 18 May, 2018 1 commit
  21. 16 May, 2018 2 commits
    • Tobias Tebbi's avatar
      [torque] implement function pointers to builtins · 07f19a08
      Tobias Tebbi authored
      This CL adds the new type expression
      builtin(Context, ArgType1, ...) => ReturnType
      and allows to use Torque-defined builtins as values of this type, as well
      as calling values of this type.
      The new function pointer types are subtypes of Code.
      
      Change-Id: Ib7ba3ce6ef7a8591a4c79230dd189fd25698d5b9
      Reviewed-on: https://chromium-review.googlesource.com/1060056
      Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
      Reviewed-by: 's avatarDaniel Clifford <danno@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#53217}
      07f19a08
    • Daniel Clifford's avatar
      [torque]: Implement Generics for Builtins and Macros · 3d2cb0b4
      Daniel Clifford authored
      Including specialization, e.g.:
      
        // Declare parameterized generic
        macro GenericMacroTest<T: type>(param: T): Object {
          return Undefined;
        }
      
        // Declare specialization of generic
        GenericMacroTest<Object>(param: Object): Object {
          return param;
        }
      
        ...
        assert(GenericMacroTest<Smi>(0) == Undefined);
        assert(GenericMacroTest<Smi>(1) == Undefined);
        assert(GenericMacroTest<Object>(Null) == Null);
        assert(GenericMacroTest<Object>(False) == False);
        ...
      
      Known issue: specialization doesn't rigorously checked to verify
      that specialization signature precisely matches generic declaration.
      
      Change-Id: I9d9d96da4c5c8c9a76550844680e9e133a5edaed
      Reviewed-on: https://chromium-review.googlesource.com/1043986
      Commit-Queue: Daniel Clifford <danno@chromium.org>
      Reviewed-by: 's avatarTobias Tebbi <tebbi@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#53203}
      3d2cb0b4
  22. 15 May, 2018 1 commit
  23. 13 May, 2018 2 commits