LCOV - code coverage report
Current view: top level - gcc/rust/backend - rust-compile-intrinsic.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 71.4 % 14 10
Test Date: 2026-11-14 16:39:50 Functions: 100.0 % 2 2
Legend: Lines:     hit not hit

            Line data    Source code
       1              : // This file is part of GCC.
       2              : 
       3              : // GCC is free software; you can redistribute it and/or modify it under
       4              : // the terms of the GNU General Public License as published by the Free
       5              : // Software Foundation; either version 3, or (at your option) any later
       6              : // version.
       7              : 
       8              : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
       9              : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
      10              : // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      11              : // for more details.
      12              : 
      13              : // You should have received a copy of the GNU General Public License
      14              : // along with GCC; see the file COPYING3.  If not see
      15              : // <http://www.gnu.org/licenses/>.
      16              : 
      17              : #include "rust-compile-intrinsic.h"
      18              : #include "rust-compile-context.h"
      19              : #include "rust-builtins.h"
      20              : #include "rust-diagnostics.h"
      21              : #include "tree-core.h"
      22              : #include "rust-intrinsic-handlers.h"
      23              : #include "rust-intrinsic-values.h"
      24              : 
      25              : namespace Rust {
      26              : namespace Compile {
      27              : 
      28              : using IValue = Values::Intrinsics;
      29              : 
      30              : static const std::map<std::string, Intrinsic::CompileFn> intrinsics = {
      31              :   {IValue::OFFSET, handlers::offset},
      32              :   {IValue::ARITH_OFFSET, handlers::arith_offset_handler},
      33              :   {IValue::WRITE_BYTES, handlers::write_bytes_handler},
      34              :   {IValue::SIZE_OF, handlers::sizeof_handler},
      35              :   {IValue::SIZE_OF_VAL, handlers::size_of_val_handler},
      36              :   {IValue::MIN_ALIGN_OF, handlers::min_align_of_handler},
      37              :   {IValue::MIN_ALIGN_OF_VAL, handlers::min_align_of_val_handler},
      38              :   {IValue::TRANSMUTE, handlers::transmute},
      39              :   {IValue::ROTATE_LEFT, handlers::rotate_left},
      40              :   {IValue::ROTATE_RIGHT, handlers::rotate_right},
      41              :   {IValue::WRAPPING_ADD, handlers::wrapping_op (PLUS_EXPR)},
      42              :   {IValue::WRAPPING_SUB, handlers::wrapping_op (MINUS_EXPR)},
      43              :   {IValue::WRAPPING_MUL, handlers::wrapping_op (MULT_EXPR)},
      44              :   {IValue::ADD_WITH_OVERFLOW, handlers::op_with_overflow (PLUS_EXPR)},
      45              :   {IValue::SUB_WITH_OVERFLOW, handlers::op_with_overflow (MINUS_EXPR)},
      46              :   {IValue::MUL_WITH_OVERFLOW, handlers::op_with_overflow (MULT_EXPR)},
      47              :   {IValue::COPY, handlers::copy (true)},
      48              :   {IValue::COPY_NONOVERLAPPING, handlers::copy (false)},
      49              :   {IValue::PREFETCH_READ_DATA, handlers::prefetch (Mode::Read, Cache::Data)},
      50              :   {IValue::PREFETCH_WRITE_DATA, handlers::prefetch (Mode::Write, Cache::Data)},
      51              :   {IValue::PREFETCH_READ_INSTRUCTION,
      52              :    handlers::prefetch (Mode::Read, Cache::Instruction)},
      53              :   {IValue::PREFETCH_WRITE_INSTRUCTION,
      54              :    handlers::prefetch (Mode::Write, Cache::Instruction)},
      55              :   {IValue::ATOMIC_STORE, handlers::atomic_store (__ATOMIC_SEQ_CST)},
      56              :   {IValue::ATOMIC_STORE_SEQCST, handlers::atomic_store (__ATOMIC_SEQ_CST)},
      57              :   {IValue::ATOMIC_STORE_REL, handlers::atomic_store (__ATOMIC_RELEASE)},
      58              :   {IValue::ATOMIC_STORE_RELEASE, handlers::atomic_store (__ATOMIC_RELEASE)},
      59              :   {IValue::ATOMIC_STORE_RELAXED, handlers::atomic_store (__ATOMIC_RELAXED)},
      60              :   {IValue::ATOMIC_STORE_UNORDERED, handlers::atomic_store (__ATOMIC_RELAXED)},
      61              :   {IValue::ATOMIC_LOAD, handlers::atomic_load (__ATOMIC_SEQ_CST)},
      62              :   {IValue::ATOMIC_LOAD_SEQCST, handlers::atomic_load (__ATOMIC_SEQ_CST)},
      63              :   {IValue::ATOMIC_LOAD_ACQ, handlers::atomic_load (__ATOMIC_ACQUIRE)},
      64              :   {IValue::ATOMIC_LOAD_ACQUIRE, handlers::atomic_load (__ATOMIC_ACQUIRE)},
      65              :   {IValue::ATOMIC_LOAD_RELAXED, handlers::atomic_load (__ATOMIC_RELAXED)},
      66              :   {IValue::ATOMIC_LOAD_UNORDERED, handlers::atomic_load (__ATOMIC_RELAXED)},
      67              :   {IValue::ATOMIC_XADD, handlers::atomic_xadd (__ATOMIC_SEQ_CST)},
      68              :   {IValue::ATOMIC_XADD_ACQ, handlers::atomic_xadd (__ATOMIC_ACQUIRE)},
      69              :   {IValue::ATOMIC_XADD_REL, handlers::atomic_xadd (__ATOMIC_RELEASE)},
      70              :   {IValue::ATOMIC_XADD_ACQREL, handlers::atomic_xadd (__ATOMIC_ACQ_REL)},
      71              :   {IValue::ATOMIC_XADD_RELAXED, handlers::atomic_xadd (__ATOMIC_RELAXED)},
      72              :   {IValue::ATOMIC_XSUB, handlers::atomic_xsub (__ATOMIC_SEQ_CST)},
      73              :   {IValue::ATOMIC_XSUB_ACQ, handlers::atomic_xsub (__ATOMIC_ACQUIRE)},
      74              :   {IValue::ATOMIC_XSUB_REL, handlers::atomic_xsub (__ATOMIC_RELEASE)},
      75              :   {IValue::ATOMIC_XSUB_ACQREL, handlers::atomic_xsub (__ATOMIC_ACQ_REL)},
      76              :   {IValue::ATOMIC_XSUB_RELAXED, handlers::atomic_xsub (__ATOMIC_RELAXED)},
      77              :   {IValue::ATOMIC_AND, handlers::atomic_and (__ATOMIC_SEQ_CST)},
      78              :   {IValue::ATOMIC_AND_ACQ, handlers::atomic_and (__ATOMIC_ACQUIRE)},
      79              :   {IValue::ATOMIC_AND_REL, handlers::atomic_and (__ATOMIC_RELEASE)},
      80              :   {IValue::ATOMIC_AND_ACQREL, handlers::atomic_and (__ATOMIC_ACQ_REL)},
      81              :   {IValue::ATOMIC_AND_RELAXED, handlers::atomic_and (__ATOMIC_RELAXED)},
      82              :   {IValue::ATOMIC_NAND, handlers::atomic_nand (__ATOMIC_SEQ_CST)},
      83              :   {IValue::ATOMIC_NAND_ACQ, handlers::atomic_nand (__ATOMIC_ACQUIRE)},
      84              :   {IValue::ATOMIC_NAND_REL, handlers::atomic_nand (__ATOMIC_RELEASE)},
      85              :   {IValue::ATOMIC_NAND_ACQREL, handlers::atomic_nand (__ATOMIC_ACQ_REL)},
      86              :   {IValue::ATOMIC_NAND_RELAXED, handlers::atomic_nand (__ATOMIC_RELAXED)},
      87              :   {IValue::ATOMIC_OR, handlers::atomic_or (__ATOMIC_SEQ_CST)},
      88              :   {IValue::ATOMIC_OR_ACQ, handlers::atomic_or (__ATOMIC_ACQUIRE)},
      89              :   {IValue::ATOMIC_OR_REL, handlers::atomic_or (__ATOMIC_RELEASE)},
      90              :   {IValue::ATOMIC_OR_ACQREL, handlers::atomic_or (__ATOMIC_ACQ_REL)},
      91              :   {IValue::ATOMIC_OR_RELAXED, handlers::atomic_or (__ATOMIC_RELAXED)},
      92              :   {IValue::ATOMIC_XOR, handlers::atomic_xor (__ATOMIC_SEQ_CST)},
      93              :   {IValue::ATOMIC_XOR_ACQ, handlers::atomic_xor (__ATOMIC_ACQUIRE)},
      94              :   {IValue::ATOMIC_XOR_REL, handlers::atomic_xor (__ATOMIC_RELEASE)},
      95              :   {IValue::ATOMIC_XOR_ACQREL, handlers::atomic_xor (__ATOMIC_ACQ_REL)},
      96              :   {IValue::ATOMIC_XOR_RELAXED, handlers::atomic_xor (__ATOMIC_RELAXED)},
      97              :   {IValue::ATOMIC_CXCHG,
      98              :    handlers::atomic_compare_exchange (false, __ATOMIC_SEQ_CST,
      99              :                                       __ATOMIC_SEQ_CST)},
     100              :   {IValue::ATOMIC_CXCHG_ACQ,
     101              :    handlers::atomic_compare_exchange (false, __ATOMIC_ACQUIRE,
     102              :                                       __ATOMIC_ACQUIRE)},
     103              :   {IValue::ATOMIC_CXCHG_REL,
     104              :    handlers::atomic_compare_exchange (false, __ATOMIC_RELEASE,
     105              :                                       __ATOMIC_RELAXED)},
     106              :   {IValue::ATOMIC_CXCHG_ACQREL,
     107              :    handlers::atomic_compare_exchange (false, __ATOMIC_ACQ_REL,
     108              :                                       __ATOMIC_ACQUIRE)},
     109              :   {IValue::ATOMIC_CXCHG_RELAXED,
     110              :    handlers::atomic_compare_exchange (false, __ATOMIC_RELAXED,
     111              :                                       __ATOMIC_RELAXED)},
     112              :   {IValue::ATOMIC_CXCHGWEAK,
     113              :    handlers::atomic_compare_exchange (true, __ATOMIC_SEQ_CST,
     114              :                                       __ATOMIC_SEQ_CST)},
     115              :   {IValue::ATOMIC_CXCHGWEAK_ACQ,
     116              :    handlers::atomic_compare_exchange (true, __ATOMIC_ACQUIRE,
     117              :                                       __ATOMIC_ACQUIRE)},
     118              :   {IValue::ATOMIC_CXCHGWEAK_REL,
     119              :    handlers::atomic_compare_exchange (true, __ATOMIC_RELEASE,
     120              :                                       __ATOMIC_RELAXED)},
     121              :   {IValue::ATOMIC_CXCHGWEAK_ACQREL,
     122              :    handlers::atomic_compare_exchange (true, __ATOMIC_ACQ_REL,
     123              :                                       __ATOMIC_ACQUIRE)},
     124              :   {IValue::ATOMIC_CXCHGWEAK_RELAXED,
     125              :    handlers::atomic_compare_exchange (true, __ATOMIC_RELAXED,
     126              :                                       __ATOMIC_RELAXED)},
     127              :   {IValue::ATOMIC_MAX,
     128              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMax,
     129              :                             __ATOMIC_SEQ_CST)},
     130              :   {IValue::ATOMIC_MAX_ACQ,
     131              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMax,
     132              :                             __ATOMIC_ACQUIRE)},
     133              :   {IValue::ATOMIC_MAX_REL,
     134              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMax,
     135              :                             __ATOMIC_RELEASE)},
     136              :   {IValue::ATOMIC_MAX_ACQREL,
     137              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMax,
     138              :                             __ATOMIC_ACQ_REL)},
     139              :   {IValue::ATOMIC_MAX_RELAXED,
     140              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMax,
     141              :                             __ATOMIC_RELAXED)},
     142              :   {IValue::ATOMIC_UMAX,
     143              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMax,
     144              :                             __ATOMIC_SEQ_CST)},
     145              :   {IValue::ATOMIC_UMAX_ACQ,
     146              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMax,
     147              :                             __ATOMIC_ACQUIRE)},
     148              :   {IValue::ATOMIC_UMAX_REL,
     149              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMax,
     150              :                             __ATOMIC_RELEASE)},
     151              :   {IValue::ATOMIC_UMAX_ACQREL,
     152              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMax,
     153              :                             __ATOMIC_ACQ_REL)},
     154              :   {IValue::ATOMIC_UMAX_RELAXED,
     155              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMax,
     156              :                             __ATOMIC_RELAXED)},
     157              :   {IValue::ATOMIC_MIN,
     158              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMin,
     159              :                             __ATOMIC_SEQ_CST)},
     160              :   {IValue::ATOMIC_MIN_ACQ,
     161              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMin,
     162              :                             __ATOMIC_ACQUIRE)},
     163              :   {IValue::ATOMIC_MIN_REL,
     164              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMin,
     165              :                             __ATOMIC_RELEASE)},
     166              :   {IValue::ATOMIC_MIN_ACQREL,
     167              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMin,
     168              :                             __ATOMIC_ACQ_REL)},
     169              :   {IValue::ATOMIC_MIN_RELAXED,
     170              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::SignedMin,
     171              :                             __ATOMIC_RELAXED)},
     172              :   {IValue::ATOMIC_UMIN,
     173              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMin,
     174              :                             __ATOMIC_SEQ_CST)},
     175              :   {IValue::ATOMIC_UMIN_ACQ,
     176              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMin,
     177              :                             __ATOMIC_ACQUIRE)},
     178              :   {IValue::ATOMIC_UMIN_REL,
     179              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMin,
     180              :                             __ATOMIC_RELEASE)},
     181              :   {IValue::ATOMIC_UMIN_ACQREL,
     182              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMin,
     183              :                             __ATOMIC_ACQ_REL)},
     184              :   {IValue::ATOMIC_UMIN_RELAXED,
     185              :    handlers::atomic_minmax (handlers::AtomicMinMaxKind::UnsignedMin,
     186              :                             __ATOMIC_RELAXED)},
     187              :   {IValue::ATOMIC_FENCE, handlers::atomic_fence (true, __ATOMIC_SEQ_CST)},
     188              :   {IValue::ATOMIC_FENCE_ACQ, handlers::atomic_fence (true, __ATOMIC_ACQUIRE)},
     189              :   {IValue::ATOMIC_FENCE_REL, handlers::atomic_fence (true, __ATOMIC_RELEASE)},
     190              :   {IValue::ATOMIC_FENCE_ACQREL,
     191              :    handlers::atomic_fence (true, __ATOMIC_ACQ_REL)},
     192              :   {IValue::ATOMIC_SINGLETHREADFENCE,
     193              :    handlers::atomic_fence (false, __ATOMIC_SEQ_CST)},
     194              :   {IValue::ATOMIC_SINGLETHREADFENCE_ACQ,
     195              :    handlers::atomic_fence (false, __ATOMIC_ACQUIRE)},
     196              :   {IValue::ATOMIC_SINGLETHREADFENCE_REL,
     197              :    handlers::atomic_fence (false, __ATOMIC_RELEASE)},
     198              :   {IValue::ATOMIC_SINGLETHREADFENCE_ACQREL,
     199              :    handlers::atomic_fence (false, __ATOMIC_ACQ_REL)},
     200              :   {IValue::UNCHECKED_ADD, handlers::unchecked_op (PLUS_EXPR)},
     201              :   {IValue::UNCHECKED_SUB, handlers::unchecked_op (MINUS_EXPR)},
     202              :   {IValue::UNCHECKED_MUL, handlers::unchecked_op (MULT_EXPR)},
     203              :   {IValue::UNCHECKED_DIV, handlers::unchecked_op (TRUNC_DIV_EXPR)},
     204              :   {IValue::UNCHECKED_REM, handlers::unchecked_op (TRUNC_MOD_EXPR)},
     205              :   {IValue::UNCHECKED_SHL, handlers::unchecked_op (LSHIFT_EXPR)},
     206              :   {IValue::UNCHECKED_SHR, handlers::unchecked_op (RSHIFT_EXPR)},
     207              :   {IValue::UNINIT, handlers::uninit},
     208              :   {IValue::MOVE_VAL_INIT, handlers::move_val_init},
     209              :   {IValue::LIKELY, handlers::expect (true)},
     210              :   {IValue::UNLIKELY, handlers::expect (false)},
     211              :   {IValue::ASSUME, handlers::assume},
     212              :   {IValue::TRY, handlers::try_handler (false)},
     213              :   {IValue::CATCH_UNWIND, handlers::try_handler (true)},
     214              :   {IValue::DISCRIMINANT_VALUE, handlers::discriminant_value},
     215              :   {IValue::VARIANT_COUNT, handlers::variant_count},
     216              :   {IValue::BSWAP, handlers::bswap_handler},
     217              :   {IValue::CTLZ, handlers::ctlz_handler},
     218              :   {IValue::CTLZ_NONZERO, handlers::ctlz_nonzero_handler},
     219              :   {IValue::CTTZ, handlers::cttz_handler},
     220              :   {IValue::CTTZ_NONZERO, handlers::cttz_nonzero_handler},
     221              :   {IValue::FADD_FAST, handlers::fop_fast (ArithmeticOrLogicalOperator::ADD)},
     222              :   {IValue::FSUB_FAST,
     223              :    handlers::fop_fast (ArithmeticOrLogicalOperator::SUBTRACT)},
     224              :   {IValue::FMUL_FAST,
     225              :    handlers::fop_fast (ArithmeticOrLogicalOperator::MULTIPLY)},
     226              :   {IValue::FDIV_FAST, handlers::fop_fast (ArithmeticOrLogicalOperator::DIVIDE)},
     227              :   {IValue::FREM_FAST,
     228              :    handlers::fop_fast (ArithmeticOrLogicalOperator::MODULUS)},
     229              :   {IValue::FLOAT_TO_INT_UNCHECKED, handlers::float_to_int_unchecked},
     230              :   {IValue::EXACT_DIV, handlers::exact_div_handler},
     231              :   {IValue::NONTEMPORAL_STORE, handlers::nontemporal_store},
     232              :   {IValue::BREAKPOINT, handlers::breakpoint},
     233              :   {IValue::PREF_ALIGN_OF, handlers::sorry},
     234              :   {IValue::ASSERT_ZERO_VALID, handlers::type_assert (TyAssert::ZeroValid)},
     235              :   {IValue::ASSERT_INHABITED, handlers::type_assert (TyAssert::Inhabited)},
     236              :   {IValue::ASSERT_UNINIT_VALID, handlers::type_assert (TyAssert::UninitValid)},
     237              :   {IValue::PTR_OFFSET_FROM, handlers::ptr_offset_from},
     238              : };
     239              : 
     240         4418 : Intrinsics::Intrinsics (Context *ctx) : ctx (ctx) {}
     241              : 
     242              : /**
     243              :  * Returns a FUNC_DECL corresponding to the intrinsic function FNTYPE. If a
     244              :  * corresponding builtin exists, returns it. If not, search in the generic
     245              :  * intrinsics declared and delegate the return to the corresponding handler.
     246              :  *
     247              :  * @param fntype The Rust function type that should be implemented by the
     248              :  * compiler
     249              :  */
     250              : tree
     251         4418 : Intrinsics::compile (TyTy::FnType *fntype, location_t expr_locus)
     252              : {
     253         4418 :   rust_assert (fntype->get_abi () == ABI::INTRINSIC);
     254              : 
     255         4418 :   BuiltinsContext &builtin_ctx = BuiltinsContext::get ();
     256              : 
     257         8836 :   if (auto builtin
     258         4418 :       = builtin_ctx.lookup_simple_builtin (fntype->get_identifier ()))
     259          449 :     return *builtin;
     260              : 
     261              :   // is it a more complex intrinsic?
     262         7938 :   auto it = intrinsics.find (fntype->get_identifier ());
     263         3969 :   if (it != intrinsics.end ())
     264         3969 :     return Intrinsic (it->second).compile (ctx, fntype, expr_locus);
     265              : 
     266            0 :   location_t locus = ctx->get_mappings ().lookup_location (fntype->get_ref ());
     267            0 :   rust_error_at (locus, ErrorCode::E0093,
     268              :                  "unrecognized intrinsic function: %qs",
     269            0 :                  fntype->get_identifier ().c_str ());
     270              : 
     271            0 :   return error_mark_node;
     272              : }
     273              : 
     274              : } // namespace Compile
     275              : } // namespace Rust
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.