nickg/nvc | Build 13887457702 | src/lower.c | Coveralls - Test Coverage History & Statistics

194

static inline void _lower_pop_cover_scope(lazy_cscope_t *lcs)

92,808✔

196

   assert(lcs->owner->lazy_cscope == lcs);

92,571✔

197

   lcs->owner->lazy_cscope = lcs->parent;

92,808✔

200

static bool lower_is_const(tree_t t)

71,071✔

202

   switch (tree_kind(t)) {

71,071✔

203

   case T_AGGREGATE:

11,104✔

205

         type_t type = tree_type(t);

11,104✔

206

         if (type_is_record(type) && !type_const_bounds(type))

11,104✔

209

         const int nassocs = tree_assocs(t);

10,886✔

210

         for (int i = 0; i < nassocs; i++) {

70,356✔

211

            tree_t a = tree_assoc(t, i);

60,408✔

212

            switch (tree_subkind(a)) {

60,408✔

213

            case A_NAMED:

2,759✔

214

               if (!lower_is_const(tree_name(a)))

2,759✔

217

            case A_RANGE:

336✔

220

                  tree_t r = tree_range(a, 0);

336✔

221

                  if (tree_subkind(r) == RANGE_EXPR)

336✔

223

                  else if (!lower_is_const(tree_left(r)))

336✔

225

                  else if (!lower_is_const(tree_right(r)))

336✔

231

            if (!lower_is_const(tree_value(tree_assoc(t, i))))

60,405✔

238

   case T_REF:

35,126✔

240

         tree_t decl = tree_ref(t);

35,126✔

241

         const tree_kind_t decl_kind = tree_kind(decl);

35,126✔

242

         if (decl_kind == T_CONST_DECL && type_is_scalar(tree_type(t)))

35,126✔

243

            return tree_has_value(decl) && lower_is_const(tree_value(decl));

36✔

245

            return decl_kind == T_ENUM_LIT || decl_kind == T_FIELD_DECL;

35,108✔

258

   default:

460✔

259

      return false;

460✔

263

static bool needs_bounds_var(type_t type)

30,887✔

267

   if (type_is_unconstrained(type))

30,887✔

270

      return !type_const_bounds(type);

27,073✔

273

static int dims_for_type(type_t type)

88,565✔

275

   int ndims = dimension_of(type);

88,565✔

277

   for (type_t e = type_elem(type);

88,565✔

278

        type_is_array(e) && !type_const_bounds(e);

89,854✔

279

        e = type_elem(e))

1,289✔

280

      ndims += dimension_of(e);

1,289✔

282

   return ndims;

88,565✔

285

static bool have_uarray_ptr(vcode_reg_t reg)

46,848✔

287

   vcode_type_t vtype = vcode_reg_type(reg);

46,848✔

288

   if (vtype_kind(vtype) != VCODE_TYPE_POINTER)

46,848✔

291

   return vtype_kind(vtype_pointed(vtype)) == VCODE_TYPE_UARRAY;

19,523✔

294

static bool lower_trivially_copyable(type_t type)

17,069✔

296

   if (type_is_record(type))

26,301✔

297

      return type_const_bounds(type);

1,974✔

298

   else if (type_is_array(type))

24,327✔

299

      return lower_trivially_copyable(type_elem_recur(type));

9,232✔

304

static vcode_reg_t lower_range_expr(lower_unit_t *lu, tree_t r, int *dim)

6,418✔

306

   assert(tree_subkind(r) == RANGE_EXPR);

6,418✔

308

   tree_t value = tree_value(r);

6,418✔

309

   assert(tree_kind(value) == T_ATTR_REF);

6,418✔

311

   if (tree_params(value) > 0)

6,418✔

312

      *dim = assume_int(tree_value(tree_param(value, 0)));

72✔

314

   if (tree_subkind(value) == ATTR_REVERSE_RANGE)

6,418✔

315

      *dim *= -1;

165✔

317

   tree_t prefix = tree_name(value);

6,418✔

318

   type_t type = tree_type(prefix);

6,418✔

319

   assert(!type_const_bounds(type));

6,418✔

321

   vcode_reg_t prefix_reg = lower_attr_prefix(lu, prefix);

6,418✔

322

   if (prefix_reg == VCODE_INVALID_REG)

6,418✔

323

      return lower_get_type_bounds(lu, type);

738✔

325

   assert(vcode_reg_kind(prefix_reg) == VCODE_TYPE_UARRAY);

5,680✔

329

static vcode_reg_t lower_range_left(lower_unit_t *lu, tree_t r)

64,101✔

331

   assert(tree_kind(r) == T_RANGE);

64,101✔

333

   type_t type = tree_type(r);

64,101✔

334

   vcode_type_t vtype = lower_type(type);

64,101✔

335

   vcode_type_t vbounds = lower_bounds(type);

64,101✔

337

   vcode_reg_t left_reg;

64,101✔

338

   if (tree_subkind(r) == RANGE_EXPR) {

64,101✔

339

      int dim = 1;

2,087✔

340

      vcode_reg_t array_reg = lower_range_expr(lu, r, &dim);

2,087✔

342

      if (dim < 0)

2,087✔

343

         left_reg = emit_uarray_right(array_reg, -dim - 1);

55✔

345

         left_reg = emit_uarray_left(array_reg, dim - 1);

2,032✔

348

      left_reg = lower_rvalue(lu, tree_left(r));

62,014✔

350

   return emit_cast(vtype, vbounds, left_reg);

64,101✔

353

static vcode_reg_t lower_range_right(lower_unit_t *lu, tree_t r)

48,573✔

355

   assert(tree_kind(r) == T_RANGE);

48,573✔

357

   type_t type = tree_type(r);

48,573✔

358

   vcode_type_t vtype = lower_type(type);

48,573✔

359

   vcode_type_t vbounds = lower_bounds(type);

48,573✔

361

   vcode_reg_t right_reg;

48,573✔

362

   if (tree_subkind(r) == RANGE_EXPR) {

48,573✔

363

      int dim = 1;

2,167✔

364

      vcode_reg_t array_reg = lower_range_expr(lu, r, &dim);

2,167✔

366

      if (dim < 0)

2,167✔

367

         right_reg = emit_uarray_left(array_reg, -dim - 1);

55✔

369

         right_reg = emit_uarray_right(array_reg, dim - 1);

2,112✔

371

      type_t type = tree_type(r);

2,167✔

372

      vcode_type_t vtype = lower_type(type);

2,167✔

373

      vcode_type_t vbounds = lower_bounds(type);

2,167✔

374

      return emit_cast(vtype, vbounds, right_reg);

2,167✔

377

      right_reg = lower_rvalue(lu, tree_right(r));

46,406✔

379

   return emit_cast(vtype, vbounds, right_reg);

46,406✔

382

static vcode_reg_t lower_range_dir(lower_unit_t *lu, tree_t r)

49,415✔

384

   const range_kind_t rkind = tree_subkind(r);

49,415✔

386

   switch (rkind) {

49,415✔

387

   case RANGE_TO:

47,251✔

389

      return emit_const(vtype_bool(), rkind);

47,251✔

391

   case RANGE_EXPR:

2,164✔

393

         int dim = 1;

2,164✔

394

         vcode_reg_t array_reg = lower_range_expr(lu, r, &dim);

2,164✔

396

         if (dim < 0)

2,164✔

397

            return emit_not(emit_uarray_dir(array_reg, -dim - 1));

55✔

399

            return emit_uarray_dir(array_reg, dim - 1);

2,109✔

409

static vcode_reg_t lower_array_data(vcode_reg_t reg)

131,881✔

411

   vcode_type_t type = vcode_reg_type(reg);

131,881✔

412

   switch (vtype_kind(type)) {

131,881✔

413

   case VCODE_TYPE_UARRAY:

36,591✔

414

      return emit_unwrap(reg);

36,591✔

416

   case VCODE_TYPE_POINTER:

48,256✔

417

      if (vtype_kind(vtype_pointed(type)) == VCODE_TYPE_UARRAY)

48,256✔

418

         return emit_unwrap(emit_load_indirect(reg));

327✔

431

static bool have_array_metadata(type_t type, vcode_reg_t reg)

156,320✔

433

   if (reg == VCODE_INVALID_REG)

156,320✔

435

   else if (type_const_bounds(type))

153,791✔

437

   else if (type_is_unconstrained(type)) {

77,518✔

438

      assert(reg != VCODE_INVALID_REG);

33,262✔

439

      assert(vcode_reg_kind(reg) == VCODE_TYPE_UARRAY);

33,262✔

443

      return vcode_reg_kind(reg) == VCODE_TYPE_UARRAY;

44,256✔

446

static vcode_reg_t lower_array_left(lower_unit_t *lu, type_t type, int dim,

40,896✔

449

   if (have_array_metadata(type, reg)) {

40,896✔

450

      type_t index_type = index_type_of(type, dim);

27,525✔

451

      return emit_cast(lower_type(index_type), lower_bounds(index_type),

27,525✔

455

      return lower_range_left(lu, range_of(type, dim));

13,371✔

458

static vcode_reg_t lower_array_right(lower_unit_t *lu, type_t type, int dim,

31,736✔

461

   if (have_array_metadata(type, reg)) {

31,736✔

462

      type_t index_type = index_type_of(type, dim);

18,365✔

463

      return emit_cast(lower_type(index_type), lower_bounds(index_type),

18,365✔

467

      return lower_range_right(lu, range_of(type, dim));

13,371✔

470

static vcode_reg_t lower_array_dir(lower_unit_t *lu, type_t type, int dim,

31,638✔

473

   if (have_array_metadata(type, reg))

31,638✔

474

      return emit_uarray_dir(reg, dim);

18,267✔

476

      return lower_range_dir(lu, range_of(type, dim));

13,371✔

479

static vcode_reg_t lower_array_len(lower_unit_t *lu, type_t type, int dim,

108,163✔

482

   assert(type_is_array(type));

108,163✔

484

   if (type_const_bounds(type)) {

108,163✔

485

      tree_t r = range_of(type, dim);

59,958✔

487

      int64_t low, high;

59,958✔

488

      if (!folded_bounds(r, &low, &high))

59,958✔

491

      return emit_const(vtype_offset(), MAX(high - low + 1, 0));

59,958✔

493

   else if (reg != VCODE_INVALID_REG

48,205✔

495

            && vcode_reg_kind(reg) == VCODE_TYPE_UARRAY)

47,600✔

496

      return emit_uarray_len(reg, dim);

47,185✔

498

      vcode_reg_t bounds_reg = lower_get_type_bounds(lu, type);

1,020✔

499

      return emit_uarray_len(bounds_reg, dim);

1,020✔

503

static vcode_reg_t lower_array_stride(lower_unit_t *lu, type_t type,

22,777✔

506

   vcode_type_t voffset = vtype_offset();

22,777✔

507

   vcode_reg_t stride = emit_const(voffset, 1);

22,777✔

509

   type_t elem = type_elem(type);

22,777✔

510

   if (!type_is_array(elem))

22,777✔

513

   int udims = 0, dim = 0;

3,433✔

514

   if (have_array_metadata(type, reg)) {

3,433✔

515

      udims = dims_for_type(type);

603✔

516

      dim = dimension_of(type);   // Skip to element dimensions

603✔

518

      assert(vtype_dims(vcode_reg_type(reg)) == udims);

603✔

521

   do {

3,681✔

522

      const int edims = dimension_of(elem);

3,681✔

523

      for (int i = 0; i < edims; i++, dim++) {

7,575✔

524

         vcode_reg_t len_reg;

3,894✔

525

         if (dim < udims)

3,894✔

526

            len_reg = emit_uarray_len(reg, dim);

503✔

528

            tree_t r = range_of(elem, i);

3,391✔

530

            int64_t low, high;

3,391✔

531

            if (!folded_bounds(r, &low, &high)) {

3,391✔

535

               emit_comment("Workaround for missing record type bounds");

3✔

537

               vcode_reg_t left_reg  = lower_range_left(lu, r);

3✔

538

               vcode_reg_t right_reg = lower_range_right(lu, r);

3✔

539

               vcode_reg_t dir_reg   = lower_range_dir(lu, r);

3✔

541

               len_reg = emit_range_length(left_reg, right_reg, dir_reg);

3✔

544

               len_reg = emit_const(voffset, MAX(high - low + 1, 0));

3,388✔

547

         stride = emit_mul(stride, len_reg);

3,894✔

549

   } while (type_is_array((elem = type_elem(elem))));

3,681✔

551

   emit_comment("Array of array stride is r%d", stride);

3,433✔

552

   return stride;

3,433✔

555

static vcode_reg_t lower_array_total_len(lower_unit_t *lu, type_t type,

40,557✔

558

   const int ndims = dimension_of(type);

40,557✔

560

   vcode_reg_t total = VCODE_INVALID_REG;

40,557✔

561

   for (int i = 0; i < ndims; i++) {

82,326✔

562

      vcode_reg_t this = lower_array_len(lu, type, i, reg);

41,769✔

563

      if (total == VCODE_INVALID_REG)

41,769✔

566

         total = emit_mul(this, total);

1,212✔

569

   type_t elem = type_elem(type);

40,557✔

570

   if (type_is_array(elem))

40,557✔

571

      return emit_mul(total, lower_array_stride(lu, type, reg));

1,616✔

576

static vcode_reg_t lower_type_width(lower_unit_t *lu, type_t type,

18,462✔

579

   if (type_is_array(type))

18,462✔

580

      return lower_array_total_len(lu, type, reg);

3,493✔

582

      assert(type_is_scalar(type));

14,969✔

583

      return emit_const(vtype_offset(), 1);

14,969✔

587

static int lower_array_const_size(type_t type)

23,886✔

589

   const int ndims = dimension_of(type);

23,886✔

591

   int size = 1;

23,886✔

592

   for (int i = 0; i < ndims; i++) {

50,340✔

593

      tree_t r = range_of(type, i);

26,454✔

594

      int64_t low, high;

26,454✔

595

      range_bounds(r, &low, &high);

26,454✔

596

      size *= MAX(high - low + 1, 0);

26,454✔

599

   type_t elem = type_elem(type);

23,886✔

600

   return type_is_array(elem) ? size * lower_array_const_size(elem) : size;

23,886✔

603

static vcode_type_t lower_array_type(type_t type)

48,059✔

605

   type_t elem = type_elem_recur(type);

48,059✔

607

   vcode_type_t elem_type   = lower_type(elem);

48,059✔

608

   vcode_type_t elem_bounds = lower_bounds(elem);

48,059✔

610

   if (type_const_bounds(type))

48,059✔

611

      return vtype_carray(lower_array_const_size(type), elem_type, elem_bounds);

12,463✔

613

      return vtype_uarray(dims_for_type(type), elem_type, elem_bounds);

35,596✔

616

vcode_type_t lower_type(type_t type)

893,812✔

618

   switch (type_kind(type)) {

1,157,780✔

619

   case T_SUBTYPE:

286,645✔

620

      if (type_is_array(type))

286,645✔

621

         return lower_array_type(type);

22,677✔

623

         return lower_type(type_base(type));

263,968✔

625

   case T_ARRAY:

25,382✔

626

      return lower_array_type(type);

25,382✔

628

   case T_PHYSICAL:

449,211✔

631

         tree_t r = type_dim(type, 0);

449,211✔

632

         int64_t low, high;

449,211✔

633

         const bool folded = folded_bounds(r, &low, &high);

449,211✔

634

         if (folded)

449,211✔

635

            return vtype_int(low, high);

449,211✔

640

   case T_ENUM:

312,789✔

641

      return vtype_int(0, type_enum_literals(type) - 1);

312,789✔

643

   case T_RECORD:

23,753✔

645

         ident_t name = type_ident(type);

23,753✔

646

         vcode_type_t record = vtype_find_named_record(name);

23,753✔

647

         if (record == VCODE_INVALID_TYPE) {

23,753✔

648

            vtype_named_record(name, NULL, 0);  // Forward-declare the name

4,323✔

650

            const int nfields = type_fields(type);

4,323✔

651

            vcode_type_t fields[nfields];

4,323✔

652

            for (int i = 0; i < nfields; i++)

17,904✔

653

               fields[i] = lower_type(tree_type(type_field(type, i)));

13,581✔

655

            record = vtype_named_record(name, fields, nfields);

4,323✔

661

   case T_PROTECTED:

1,472✔

662

      return vtype_context(type_ident(type));

1,472✔

664

   case T_FILE:

618✔

665

      return vtype_file(lower_type(type_designated(type)));

618✔

667

   case T_ACCESS:

3,945✔

669

         type_t access = type_designated(type);

3,945✔

670

         if (type_is_array(access) && type_const_bounds(access))

3,945✔

671

            return vtype_access(lower_type(type_elem_recur(access)));

175✔

673

            return vtype_access(lower_type(access));

3,770✔

676

   case T_REAL:

52,874✔

678

         tree_t r = type_dim(type, 0);

52,874✔

679

         double low, high;

52,874✔

680

         const bool folded = folded_bounds_real(r, &low, &high);

52,874✔

681

         if (folded)

52,874✔

682

            return vtype_real(low, high);

52,874✔

687

   case T_INCOMPLETE:

1,091✔

688

      return vtype_opaque();

1,091✔

695

vcode_type_t lower_bounds(type_t type)

326,270✔

697

   if (type_kind(type) == T_SUBTYPE) {

326,270✔

698

      if (type_is_integer(type) || type_is_enum(type)) {

148,193✔

699

         tree_t r = range_of(type, 0);

130,199✔

700

         int64_t low, high;

130,199✔

701

         if (folded_bounds(r, &low, &high))

130,199✔

702

            return vtype_int(low, high);

128,918✔

704

      else if (type_is_real(type)) {

17,994✔

705

         tree_t r = range_of(type, 0);

187✔

706

         double low, high;

187✔

707

         if (folded_bounds_real(r, &low, &high))

187✔

708

            return vtype_real(low, high);

186✔

712

   if (type_is_array(type))

197,166✔

713

      return lower_bounds(type_elem(type));

33,517✔

715

   return lower_type(type);

163,649✔

718

static vcode_type_t lower_signal_type(type_t type)

27,086✔

720

   if (type_is_array(type)) {

27,086✔

721

      if (type_is_homogeneous(type)) {

8,801✔

722

         vcode_type_t base = vtype_signal(lower_type(type_elem_recur(type)));

7,709✔

723

         if (type_const_bounds(type))

7,709✔

726

            return vtype_uarray(dims_for_type(type), base, base);

2,078✔

729

         vcode_type_t base = lower_signal_type(type_elem_recur(type));

1,092✔

730

         if (type_const_bounds(type))

1,092✔

731

            return vtype_carray(lower_array_const_size(type), base, base);

365✔

733

            return vtype_uarray(dims_for_type(type), base, base);

727✔

736

   else if (type_is_record(type)) {

18,285✔

737

      type_t base = type_base_recur(type);

3,138✔

738

      ident_t name = ident_prefix(type_ident(base), ident_new("$"), '\0');

3,138✔

739

      vcode_type_t record = vtype_find_named_record(name);

3,138✔

740

      if (record == VCODE_INVALID_TYPE) {

3,138✔

741

         vtype_named_record(name, NULL, 0);  // Forward-declare the name

1,573✔

743

         const int nfields = type_fields(base);

1,573✔

744

         vcode_type_t fields[nfields];

1,573✔

745

         for (int i = 0; i < nfields; i++)

7,534✔

746

            fields[i] = lower_signal_type(tree_type(type_field(base, i)));

5,961✔

748

         record = vtype_named_record(name, fields, nfields);

1,573✔

751

      return record;

3,138✔

754

      return vtype_signal(lower_type(type));

15,147✔

757

static vcode_reg_t lower_debug_locus(tree_t t)

119,810✔

759

   return emit_debug_locus(tree_to_object(t));

119,810✔

762

static vcode_reg_t lower_wrap_with_new_bounds(lower_unit_t *lu,

24,944✔

767

24,944✔

768

   assert(type_is_array(from_type));

24,944✔

769

   assert(type_is_array(to_type));

24,944✔

771

   const int ncons = dims_for_type(to_type);

24,944✔

772

   vcode_dim_t dims[ncons];

24,944✔

773

   int dptr = 0;

24,944✔

775

   int udims = 0;

24,944✔

776

   if (have_array_metadata(from_type, array)) {

24,944✔

777

      udims = dims_for_type(from_type);

2,532✔

778

      assert(vtype_dims(vcode_reg_type(array)) == udims);

2,532✔

781

   for (; dptr < ncons; from_type = type_elem(from_type),

75,296✔

782

           to_type = type_elem(to_type)) {

25,176✔

784

      const int ndims = dimension_of(from_type);

25,176✔

785

      for (int i = 0; i < ndims; i++, dptr++) {

50,446✔

786

         if (dptr < udims) {

25,270✔

787

            dims[dptr].left  = emit_uarray_left(array, dptr);

2,538✔

788

            dims[dptr].right = emit_uarray_right(array, dptr);

2,538✔

789

            dims[dptr].dir   = emit_uarray_dir(array, dptr);

2,538✔

792

            type_t src_type =

45,464✔

793

               type_is_unconstrained(to_type) ? from_type : to_type;

22,732✔

794

            tree_t r = range_of(src_type, i);

22,732✔

795

            dims[dptr].left  = lower_range_left(lu, r);

22,732✔

796

            dims[dptr].right = lower_range_right(lu, r);

22,732✔

797

            dims[dptr].dir   = lower_range_dir(lu, r);

22,732✔

802

   assert(dptr == ncons);

24,944✔

804

   return emit_wrap(lower_array_data(data), dims, ncons);

24,944✔

807

static vcode_reg_t lower_wrap(lower_unit_t *lu, type_t type, vcode_reg_t data)

3,071✔

809

   return lower_wrap_with_new_bounds(lu, type, type, data, data);

3,071✔

812

static vcode_reg_t lower_wrap_element(lower_unit_t *lu, type_t type,

339✔

814

339✔

815

   assert(type_is_array(type));

339✔

816

   assert(!type_const_bounds(type_elem(type)));

339✔

817

   assert(array != VCODE_INVALID_REG);

339✔

819

   const int ndims = dimension_of(type);

339✔

820

   const int ncons = vtype_dims(vcode_reg_type(array)) - ndims;

339✔

821

   assert(ncons > 0);

339✔

823

   vcode_dim_t dims[ncons];

339✔

824

   for (int i = 0; i < ncons; i++) {

693✔

825

      dims[i].left  = emit_uarray_left(array, ndims + i);

354✔

826

      dims[i].right = emit_uarray_right(array, ndims + i);

354✔

827

      dims[i].dir   = emit_uarray_dir(array, ndims + i);

354✔

830

   return emit_wrap(lower_array_data(data), dims, ncons);

339✔

833

static vcode_reg_t lower_rewrap(vcode_reg_t data, vcode_reg_t bounds)

6,145✔

834

6,145✔

835

   const int ndims = vtype_dims(vcode_reg_type(bounds));

6,145✔

836

   vcode_dim_t dims[ndims];

6,145✔

838

   for (int i = 0; i < ndims; i++) {

12,425✔

839

      dims[i].left  = emit_uarray_left(bounds, i);

6,280✔

840

      dims[i].right = emit_uarray_right(bounds, i);

6,280✔

841

      dims[i].dir   = emit_uarray_dir(bounds, i);

6,280✔

844

   return emit_wrap(data, dims, ndims);

6,145✔

847

static void lower_for_each_field_2(lower_unit_t *lu, type_t type1, type_t type2,

4,592✔

852

   assert(type2 == NULL || type_eq(type1, type2));

4,592✔

854

   if (type_is_array(type1)) {

4,592✔

855

      assert(!type_is_homogeneous(type1));   // Otherwise why call this

853✔

857

      if (have_uarray_ptr(rec1_ptr))

853✔

858

         rec1_ptr = emit_load_indirect(rec1_ptr);

97✔

860

      if (rec2_ptr != VCODE_INVALID_REG && have_uarray_ptr(rec2_ptr))

853✔

861

         rec2_ptr = emit_load_indirect(rec2_ptr);

14✔

863

      if (locus != VCODE_INVALID_REG && rec2_ptr != VCODE_INVALID_REG)

853✔

864

         lower_check_array_sizes(lu, type1, type2, rec1_ptr, rec2_ptr, locus);

289✔

866

      vcode_type_t voffset = vtype_offset();

853✔

867

      vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

853✔

868

      emit_store(emit_const(voffset, 0), i_var);

853✔

870

      vcode_reg_t count1_reg = lower_array_total_len(lu, type1, rec1_ptr);

853✔

871

      vcode_reg_t data1_reg  = lower_array_data(rec1_ptr);

853✔

873

      vcode_block_t body_bb = emit_block();

853✔

874

      vcode_block_t exit_bb = emit_block();

853✔

876

      vcode_block_t null_reg = emit_cmp(VCODE_CMP_EQ, count1_reg,

853✔

878

      emit_cond(null_reg, exit_bb, body_bb);

853✔

880

      vcode_select_block(body_bb);

853✔

882

      vcode_reg_t i_reg = emit_load(i_var);

853✔

883

      vcode_reg_t ptr1_reg = emit_array_ref(data1_reg, i_reg);

853✔

885

      vcode_reg_t ptr2_reg = VCODE_INVALID_REG;

853✔

886

      if (rec2_ptr != VCODE_INVALID_REG) {

853✔

887

         vcode_reg_t data2_reg = lower_array_data(rec2_ptr);

398✔

888

         ptr2_reg = emit_array_ref(data2_reg, i_reg);

398✔

891

      type_t elem1 = type_elem_recur(type1);

853✔

892

      type_t elem2 = type2 == NULL ? NULL : type_elem_recur(type2);

853✔

893

      lower_for_each_field_2(lu, elem1, elem2, ptr1_reg, ptr2_reg, locus,

853✔

896

      vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1));

853✔

897

      emit_store(next_reg, i_var);

853✔

899

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count1_reg);

853✔

900

      emit_cond(done_reg, exit_bb, body_bb);

853✔

902

      vcode_select_block(exit_bb);

853✔

903

      lower_release_temp(lu, i_var);

853✔

906

      assert(vcode_reg_kind(rec1_ptr) == VCODE_TYPE_POINTER);

3,739✔

908

      const int nfields = type_fields(type1);

3,739✔

909

      for (int i = 0; i < nfields; i++) {

16,117✔

910

         tree_t f = type_field(type1, i);

12,378✔

911

         vcode_reg_t f1_reg = emit_record_ref(rec1_ptr, i);

12,378✔

912

         vcode_reg_t f2_reg = VCODE_INVALID_REG;

12,378✔

913

         if (rec2_ptr != VCODE_INVALID_REG)

12,378✔

914

            f2_reg = emit_record_ref(rec2_ptr, i);

7,619✔

915

         (*fn)(lu, f, f1_reg, f2_reg, locus, context);

12,378✔

918

4,592✔

920

static void lower_for_each_field(lower_unit_t *lu, type_t type,

1,643✔

924

   lower_for_each_field_2(lu, type, type, rec1_ptr, VCODE_INVALID_REG,

1,643✔

926

1,643✔

928

static void lower_get_scalar_type_bounds(lower_unit_t *lu, type_t type,

19,796✔

933

   assert(type_is_scalar(type));

19,796✔

935

   tree_t r = range_of(type, 0);

19,796✔

936

   const range_kind_t rkind = tree_subkind(r);

19,796✔

938

   if (rkind != RANGE_EXPR) {

19,796✔

939

      tree_t left = tree_left(r), right = tree_right(r);

19,658✔

941

      int64_t ileft, iright;

19,658✔

942

      double rleft, rright;

19,658✔

943

      if (folded_int(left, &ileft) && folded_int(right, &iright)) {

19,658✔

944

         vcode_type_t vtype = lower_type(type);

12,973✔

945

         *left_reg  = emit_const(vtype, ileft);

12,973✔

946

         *right_reg = emit_const(vtype, iright);

12,973✔

947

         *dir_reg   = emit_const(vtype_bool(), rkind);

12,973✔

948

         return;

19,011✔

950

      else if (folded_real(left, &rleft) && folded_real(right, &rright)) {

6,685✔

951

         vcode_type_t vtype = lower_type(type);

6,038✔

952

         *left_reg  = emit_const_real(vtype, rleft);

6,038✔

953

         *right_reg = emit_const_real(vtype, rright);

6,038✔

954

         *dir_reg   = emit_const(vtype_bool(), rkind);

6,038✔

955

         return;

6,038✔

959

   if (type_has_ident(type) && needs_bounds_var(type)) {

1,321✔

960

      vcode_type_t vtype = lower_type(type);

536✔

961

      vcode_type_t vbounds = lower_bounds(type);

536✔

963

      vcode_reg_t wrap_reg;

536✔

964

      int hops = 0;

536✔

965

      vcode_var_t var = lower_search_vcode_obj(type, lu, &hops);

536✔

966

      if (var == VCODE_INVALID_VAR) {

536✔

968

         ident_t id = type_ident(type);

257✔

969

         vcode_reg_t context = emit_link_package(ident_runtil(id, '.'));

257✔

970

         vcode_type_t vuarray = vtype_uarray(1, vtype, vbounds);

257✔

971

         vcode_reg_t ptr_reg = emit_link_var(context, id, vuarray);

257✔

972

         wrap_reg = emit_load_indirect(ptr_reg);

257✔

974

      else if (hops == 0)

279✔

975

         wrap_reg = emit_load(var);

279✔

981

      *left_reg  = emit_cast(vtype, vbounds, emit_uarray_left(wrap_reg, 0));

536✔

982

      *right_reg = emit_cast(vtype, vbounds, emit_uarray_right(wrap_reg, 0));

536✔

983

      *dir_reg   = emit_uarray_dir(wrap_reg, 0);

536✔

986

      *left_reg  = lower_range_left(lu, r);

249✔

987

      *right_reg = lower_range_right(lu, r);

249✔

988

      *dir_reg   = lower_range_dir(lu, r);

249✔

992

static vcode_reg_t lower_scalar_type_left(lower_unit_t *lu, type_t type)

21,395✔

994

   assert(type_is_scalar(type));

21,395✔

996

   tree_t r = range_of(type, 0);

21,395✔

997

   const range_kind_t rkind = tree_subkind(r);

21,395✔

999

   if (rkind != RANGE_EXPR) {

21,395✔

1000

      tree_t left = tree_left(r);

21,392✔

1004

      double rleft;

21,392✔

1005

      int64_t ileft;

21,392✔

1006

      if (folded_int(left, &ileft))

21,392✔

1007

         return emit_const(lower_type(type), ileft);

21,380✔

1008

      else if (folded_real(left, &rleft))

1,386✔

1009

         return emit_const_real(lower_type(type), rleft);

1,374✔

1012

   vcode_reg_t left_reg, right_reg, dir_reg;

15✔

1013

   lower_get_scalar_type_bounds(lu, type, &left_reg, &right_reg, &dir_reg);

15✔

1015

   return left_reg;

15✔

1018

static void lower_check_scalar_bounds(lower_unit_t *lu, vcode_reg_t value,

67,924✔

1021

   tree_t r = range_of(type, 0);

67,924✔

1023

   int64_t low, high;

67,924✔

1024

   if (folded_bounds(r, &low, &high) && low <= high) {

67,924✔

1025

      vcode_type_t vbounds = vcode_reg_bounds(value);

61,614✔

1026

      if (vtype_low(vbounds) >= low && vtype_high(vbounds) <= high)

61,614✔

1027

         return;   // Avoid generating debug locus

59,117✔

1030

   vcode_reg_t left_reg, right_reg, dir_reg;

8,807✔

1031

   lower_get_scalar_type_bounds(lu, type, &left_reg, &right_reg, &dir_reg);

8,807✔

1033

   vcode_reg_t locus = lower_debug_locus(where);

8,807✔

1035

   vcode_reg_t hint_locus = locus;

8,807✔

1036

   if (hint != NULL && hint != where)

8,807✔

1037

      hint_locus = lower_debug_locus(hint);

5,661✔

1039

   emit_range_check(value, left_reg, right_reg, dir_reg, locus, hint_locus);

8,807✔

1042

static bool lower_have_signal(vcode_reg_t reg)

142,464✔

1044

   return vtype_is_signal(vcode_reg_type(reg));

142,464✔

1047

static vcode_reg_t lower_coerce_arrays(lower_unit_t *lu, type_t from, type_t to,

45,542✔

1050

   vcode_type_t reg_vtype = vcode_reg_type(reg);

45,542✔

1051

   const bool have_uarray = vtype_kind(reg_vtype) == VCODE_TYPE_UARRAY;

45,542✔

1052

   const bool need_uarray = !type_const_bounds(to);

45,542✔

1054

   if (have_uarray && need_uarray && vtype_dims(reg_vtype) == dims_for_type(to))

45,542✔

1056

   else if (need_uarray) {

26,952✔

1058

      return lower_wrap_with_new_bounds(lu, from, to, reg, reg);

20,957✔

1060

   else if (have_uarray && !need_uarray) {

5,995✔

1062

      return emit_unwrap(reg);

107✔

1068

static void lower_resolved_field_cb(lower_unit_t *lu, tree_t field,

1,489✔

1072

   type_t ftype = tree_type(field);

1,489✔

1073

   if (!type_is_homogeneous(ftype)) {

1,489✔

1074

      if (have_uarray_ptr(dst_ptr)) {

78✔

1076

         assert(have_uarray_ptr(field_ptr));

3✔

1078

         vcode_reg_t field_reg = emit_load_indirect(field_ptr);

3✔

1079

         vcode_reg_t count_reg = lower_array_total_len(lu, ftype, field_reg);

3✔

1081

         type_t elem = type_elem_recur(ftype);

3✔

1082

         vcode_type_t vtype = lower_type(elem);

3✔

1083

         vcode_type_t vbounds = lower_bounds(elem);

3✔

1085

         vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, count_reg);

3✔

1087

         vcode_reg_t wrap_reg =

3✔

1088

            lower_wrap_with_new_bounds(lu, ftype, ftype, field_reg, mem_reg);

3✔

1089

         emit_store_indirect(wrap_reg, dst_ptr);

3✔

1092

      lower_for_each_field_2(lu, ftype, ftype, field_ptr, dst_ptr, locus,

78✔

1096

      resolved_fn_t fn = ctx;

1,411✔

1097

      vcode_reg_t sig_reg = emit_load_indirect(field_ptr);

1,411✔

1099

      if (type_is_array(ftype)) {

1,411✔

1100

         vcode_reg_t count_reg = lower_array_total_len(lu, ftype, sig_reg);

628✔

1101

         vcode_reg_t r_reg = (*fn)(lower_array_data(sig_reg), count_reg);

628✔

1103

         if (type_const_bounds(ftype))

628✔

1104

            emit_copy(dst_ptr, r_reg, count_reg);

548✔

1106

            vcode_reg_t wrap_reg = lower_rewrap(r_reg, sig_reg);

80✔

1107

            emit_store_indirect(wrap_reg, dst_ptr);

80✔

1111

         vcode_reg_t r_reg = (*fn)(sig_reg, VCODE_INVALID_REG);

783✔

1112

         emit_store_indirect(emit_load_indirect(r_reg), dst_ptr);

783✔

1115

1,489✔

1117

static vcode_reg_t lower_signal_record_aggregate(lower_unit_t *lu, tree_t expr)

6✔

1119

   type_t type = tree_type(expr);

6✔

1120

   const int nfields = type_fields(type);

6✔

1121

   const int nassocs = tree_assocs(expr);

6✔

1123

   vcode_reg_t *vals LOCAL = xcalloc_array(nfields, sizeof(vcode_reg_t));

12✔

1124

   for (int i = 0; i < nfields; i++)

24✔

1125

      vals[i] = VCODE_INVALID_REG;

18✔

1127

   type_t *value_types LOCAL = xcalloc_array(nfields, sizeof(type));

6✔

1129

   for (int i = 0; i < nassocs; i++) {

24✔

1130

      tree_t a = tree_assoc(expr, i);

18✔

1131

      tree_t value = tree_value(a);

18✔

1133

      int pos = 0;

18✔

1134

      switch (tree_subkind(a)) {

18✔

1138

      case A_NAMED:

18✔

1139

         pos = tree_pos(tree_ref(tree_name(a)));

18✔

1140

         break;

18✔

1146

      vals[pos] = lower_lvalue(lu, value);

18✔

1147

      value_types[pos] = tree_type(value);

18✔

1150

   for (int i = 0; i < nfields; i++)

24✔

1151

      assert(vals[i] != VCODE_INVALID_REG);

18✔

1153

   vcode_type_t vtype = lower_signal_type(type);

6✔

1154

   vcode_var_t tmp_var = lower_temp_var(lu, "signalagg", vtype, vtype);

6✔

1155

   vcode_reg_t mem_reg = emit_index(tmp_var, VCODE_INVALID_REG);

6✔

1157

   for (int i = 0; i < nfields; i++) {

24✔

1158

      type_t ftype = tree_type(type_field(type, i));

18✔

1159

      vcode_reg_t ptr_reg = emit_record_ref(mem_reg, i);

18✔

1160

      vcode_reg_t val_reg = vals[i];

18✔

1161

      assert(lower_have_signal(val_reg));

18✔

1163

      if (type_is_record(ftype))

18✔

1166

         emit_store_indirect(val_reg, ptr_reg);

18✔

1169

   return mem_reg;

6✔

1172

static vcode_reg_t lower_signal_array_aggregate(lower_unit_t *lu, tree_t expr)

6✔

1174

   const int nassocs = tree_assocs(expr);

6✔

1175

   if (nassocs != 1)

6✔

1179

   tree_t a0 = tree_assoc(expr, 0);

6✔

1180

   vcode_reg_t a0_reg = lower_lvalue(lu, tree_value(a0));

6✔

1182

   type_t type = tree_type(expr);

6✔

1183

   if (type_is_unconstrained(type)) {

6✔

1190

   else if (!type_const_bounds(type))

6✔

1196

static vcode_reg_t lower_subprogram_arg(lower_unit_t *lu, tree_t fcall,

154,049✔

1199

   if (nth >= tree_params(fcall))

154,049✔

1202

   tree_t param = tree_param(fcall, nth);

145,465✔

1204

   assert(tree_subkind(param) == P_POS);

145,465✔

1205

   assert(tree_pos(param) == nth);

145,465✔

1207

   tree_t value = tree_value(param);

145,465✔

1208

   tree_t decl = tree_ref(fcall);

145,465✔

1210

   port_mode_t mode = PORT_IN;

145,465✔

1211

   if (nth < tree_ports(decl))

145,465✔

1212

      mode = tree_subkind(tree_port(decl, nth));

145,465✔

1214

   tree_t port = NULL;

145,465✔

1215

   if (!is_open_coded_builtin(tree_subkind(decl)))

145,465✔

1216

      port = tree_port(decl, nth);

64,502✔

1218

   type_t value_type = tree_type(value);

145,465✔

1219

   type_t port_type = port ? tree_type(port) : value_type;

145,465✔

1221

   const class_t class = port ? tree_class(port) : C_DEFAULT;

145,465✔

1223

   vcode_reg_t reg;

64,502✔

1224

   if (class == C_SIGNAL && tree_kind(value) == T_AGGREGATE) {

64,502✔

1225

      if (type_is_record(value_type))

12✔

1226

         reg = lower_signal_record_aggregate(lu, value);

6✔

1228

         reg = lower_signal_array_aggregate(lu, value);

6✔

1230

   else if (class == C_SIGNAL || class == C_FILE || mode != PORT_IN)

145,453✔

1231

      reg = lower_lvalue(lu, value);

5,374✔

1233

      reg = lower_rvalue(lu, value);

140,079✔

1235

   if (reg == VCODE_INVALID_REG)

145,465✔

1238

   if (type_is_array(value_type)) {

145,465✔

1239

      if (port != NULL && !type_is_unconstrained(port_type)) {

32,014✔

1240

         vcode_reg_t locus = lower_debug_locus(port);

365✔

1241

         lower_check_array_sizes(lu, port_type, value_type,

365✔

1244

      return lower_coerce_arrays(lu, value_type, port_type, reg);

32,014✔

1246

   else if (class == C_SIGNAL || class == C_FILE)

113,451✔

1248

   else if (mode == PORT_OUT || port == NULL || !type_is_scalar(port_type))

112,276✔

1249

      return reg;

85,220✔

1250

   else if (mode == PORT_INOUT) {

27,056✔

1251

      vcode_reg_t scalar_reg = emit_load_indirect(reg);

141✔

1252

      lower_check_scalar_bounds(lu, scalar_reg, port_type, value, port);

141✔

1253

      return reg;

141✔

1256

      lower_check_scalar_bounds(lu, reg, port_type, value, port);

26,915✔

1257

      return reg;

26,915✔

1261

static void lower_signal_flag_field_cb(lower_unit_t *lu, tree_t field,

24✔

1266

   type_t ftype = tree_type(field);

24✔

1267

   if (!type_is_homogeneous(ftype))

24✔

1271

      struct {

24✔

1274

      } *args = __ctx;

24✔

1276

      vcode_reg_t flag;

24✔

1277

      if (type_is_array(ftype)) {

24✔

1283

         vcode_reg_t nets_reg = emit_load_indirect(field_ptr);

24✔

1284

         flag = (*args->fn)(nets_reg, emit_const(vtype_offset(), 1));

24✔

1287

      vcode_reg_t cur_reg = emit_load(args->result);

24✔

1288

      vcode_reg_t new_reg = emit_or(cur_reg, flag);

24✔

1289

      emit_store(new_reg, args->result);

24✔

1291

24✔

1293

static vcode_reg_t lower_signal_flag(lower_unit_t *lu, tree_t ref,

530✔

1296

   vcode_reg_t nets = lower_lvalue(lu, ref);

530✔

1297

   if (nets == VCODE_INVALID_REG)

530✔

1300

   type_t type = tree_type(ref);

530✔

1301

   if (!type_is_homogeneous(type)) {

530✔

1302

      vcode_type_t vbool = vtype_bool();

21✔

1303

      vcode_var_t tmp_var = lower_temp_var(lu, "flag", vbool, vbool);

21✔

1304

      emit_store(emit_const(vbool, 0), tmp_var);

21✔

1306

      struct {

21✔

1309

      } args = { fn, tmp_var };

21✔

1310

      lower_for_each_field(lu, type, nets, VCODE_INVALID_REG,

21✔

1313

      vcode_reg_t result_reg = emit_load(tmp_var);

21✔

1314

      lower_release_temp(lu, tmp_var);

21✔

1315

      return result_reg;

21✔

1317

   else if (type_is_array(type)) {

509✔

1318

      vcode_reg_t data_reg = lower_array_data(nets);

100✔

1319

      vcode_reg_t len_reg = lower_array_total_len(lu, type, nets);

100✔

1320

      return (*fn)(data_reg, len_reg);

100✔

1323

      return (*fn)(nets, emit_const(vtype_offset(), 1));

409✔

1326

static vcode_reg_t lower_last_value(lower_unit_t *lu, tree_t ref)

53✔

1328

   vcode_reg_t nets = lower_lvalue(lu, ref);

53✔

1330

   type_t type = tree_type(ref);

53✔

1331

   if (type_is_homogeneous(type)) {

53✔

1332

      vcode_reg_t data_reg =

41✔

1333

         emit_last_value(lower_array_data(nets), VCODE_INVALID_REG);

41✔

1334

      if (vcode_reg_kind(nets) == VCODE_TYPE_UARRAY)

41✔

1335

         return lower_rewrap(data_reg, nets);

3✔

1343

      ident_t base_id = type_ident(type_base_recur(type));

12✔

1344

      ident_t helper_func = ident_prefix(base_id, ident_new("last_value"), '$');

12✔

1346

      vcode_reg_t arg_reg = nets;

12✔

1347

      if (type_is_array(type) && vcode_reg_kind(arg_reg) != VCODE_TYPE_UARRAY)

12✔

1348

         arg_reg = lower_wrap(lu, type, nets);

6✔

1350

      vcode_type_t vrtype = lower_func_result_type(type);

12✔

1352

      vcode_reg_t context_reg = lower_context_for_call(lu, helper_func);

12✔

1353

      vcode_reg_t args[] = { context_reg, arg_reg };

12✔

1354

      return emit_fcall(helper_func, vrtype, vrtype, args, 2);

12✔

1358

static type_t lower_arg_type(tree_t fcall, int nth)

79,460✔

1360

   if (nth >= tree_params(fcall))

79,460✔

1363

      return tree_type(tree_value(tree_param(fcall, nth)));

70,876✔

1366

static vcode_reg_t lower_wrap_string(const char *str)

2,824✔

1367

2,824✔

1368

   const size_t len = strlen(str);

2,824✔

1369

   vcode_reg_t chars[len + 1];

2,824✔

1370

   vcode_type_t ctype = vtype_char();

2,824✔

1372

   for (int j = 0; j < len; j++)

26,271✔

1373

      chars[j] = emit_const(ctype, str[j]);

23,447✔

1375

   vcode_type_t str_type = vtype_carray(len, ctype, ctype);

2,824✔

1376

   vcode_reg_t data = emit_const_array(str_type, chars, len);

2,824✔

1378

   vcode_dim_t dim0 = {

2,824✔

1379

      .left  = emit_const(vtype_offset(), 1),

2,824✔

1380

      .right = emit_const(vtype_offset(), len),

2,824✔

1381

      .dir   = emit_const(vtype_bool(), RANGE_TO)

2,824✔

1383

   return emit_wrap(emit_address_of(data), &dim0, 1);

2,824✔

1386

static void get_hierarchical_name(text_buf_t *tb, lower_unit_t *lu,

554✔

1389

   switch (tree_kind(lu->container)) {

554✔

1390

   case T_BLOCK:

362✔

1394

      tb_append(tb, ':');

362✔

1395

      break;

362✔

1397

   case T_PROC_BODY:

45✔

1401

      get_hierarchical_name(tb, lu->parent, which);

45✔

1403

      tb_istr(tb, tree_ident(lu->container));

45✔

1405

      if (standard() >= STD_02)

45✔

1406

         type_signature(tree_type(lu->container), tb);

33✔

1408

      tb_append(tb, ':');

45✔

1409

      tb_downcase(tb);

45✔

1410

      break;

45✔

1412

   case T_PROCESS:

102✔

1413

      get_hierarchical_name(tb, lu->parent, which);

102✔

1415

      if (!(tree_flags(lu->container) & TREE_F_SYNTHETIC_NAME))

102✔

1416

         tb_istr(tb, tree_ident(lu->container));

84✔

1418

      tb_append(tb, ':');

102✔

1419

      tb_downcase(tb);

102✔

1420

      break;

102✔

1422

   case T_PROT_BODY:

45✔

1424

      if (standard() < STD_19) {

45✔

1429

      tb_append(tb, ':');

45✔

1430

      break;

45✔

1435

554✔

1437

static vcode_reg_t lower_name_attr(lower_unit_t *lu, tree_t decl,

841✔

1440

   LOCAL_TEXT_BUF tb = tb_new();

1,682✔

1441

   lower_unit_t *scope = lu;

841✔

1442

   int extra_hops = 0;

841✔

1444

   switch (tree_kind(decl)) {

841✔

1445

   case T_PACK_BODY:

355✔

1446

      decl = tree_primary(decl);

355✔

1448

   case T_PACKAGE:

370✔

1450

      tb_append(tb, ':');

370✔

1451

      tb_istr(tb, tree_ident(decl));

370✔

1452

      tb_append(tb, ':');

370✔

1453

      tb_replace(tb, '.', ':');

370✔

1454

      tb_downcase(tb);

370✔

1455

      return lower_wrap_string(tb_get(tb));

370✔

1457

   case T_INSTANCE:

3✔

1458

      tb_append(tb, ':');

3✔

1459

      tb_istr(tb, tree_ident(decl));

3✔

1460

      tb_downcase(tb);

3✔

1461

      break;

3✔

1463

   case T_BLOCK:

93✔

1471

      tb_append(tb, ':');

93✔

1472

      break;

93✔

1474

   case T_PROCESS:

30✔

1475

      tb_append(tb, ':');

30✔

1476

      tb_istr(tb, tree_ident(decl));

30✔

1477

      tb_append(tb, ':');

30✔

1478

      tb_downcase(tb);

30✔

1479

      break;

30✔

1481

   case T_PROC_DECL:

57✔

1488

         vcode_unit_t parent =

57✔

1489

            unit_registry_get_parent(lu->registry, tree_ident2(decl));

57✔

1491

         if (parent != NULL) {

57✔

1492

            for (; scope != NULL; scope = scope->parent, extra_hops++) {

123✔

1493

               if (scope->vunit == parent) {

117✔

1494

                  get_hierarchical_name(tb, scope, which);

51✔

1496

                  tb_istr(tb, tree_ident(decl));

51✔

1498

                  if (standard() >= STD_02)

51✔

1499

                     type_signature(tree_type(decl), tb);

30✔

1501

                  tb_append(tb, ':');

51✔

1502

                  tb_downcase(tb);

51✔

1503

                  break;

51✔

1512

   case T_VAR_DECL:

288✔

1520

         int obj = lower_search_vcode_obj(decl, lu, &extra_hops);

288✔

1521

         if (obj != -1) {

288✔

1522

            for (int i = 0; i < extra_hops; i++, scope = scope->parent);

433✔

1524

            get_hierarchical_name(tb, scope, which);

280✔

1526

            tb_istr(tb, tree_ident(decl));

280✔

1527

            tb_downcase(tb);

280✔

1539

   if (scope == NULL) {

463✔

1540

      tree_t container = tree_container(decl);

14✔

1541

      if (is_package((container))) {

14✔

1542

         tb_append(tb, ':');

14✔

1543

         tb_istr(tb, tree_ident(primary_unit_of(container)));

14✔

1544

         tb_append(tb, ':');

14✔

1545

         tb_replace(tb, '.', ':');

14✔

1546

         tb_istr(tb, tree_ident(decl));

14✔

1547

         if (is_container(decl) || is_subprogram(decl))

14✔

1548

            tb_append(tb, ':');

6✔

1549

         tb_downcase(tb);

14✔

1551

         return lower_wrap_string(tb_get(tb));

14✔

1557

   ident_t var_name =

457✔

1558

      well_known(which == ATTR_PATH_NAME ? W_PATH_NAME : W_INSTANCE_NAME);

651✔

1560

   int hops = 0;

457✔

1561

   vcode_var_t var = lower_search_vcode_obj(var_name, scope, &hops);

457✔

1562

   assert(var != VCODE_INVALID_VAR);

457✔

1564

   vcode_reg_t array_reg;

457✔

1565

   if (hops + extra_hops == 0)

457✔

1566

      array_reg = emit_load(var);

61✔

1568

      vcode_reg_t ptr_reg = emit_var_upref(hops + extra_hops, var);

396✔

1569

      array_reg = emit_load_indirect(ptr_reg);

396✔

1572

   if (tb_len(tb) == 0)

457✔

1575

   vcode_type_t ctype = vtype_char();

457✔

1576

   vcode_type_t voffset = vtype_offset();

457✔

1578

   const size_t suffix_len = tb_len(tb);

457✔

1579

   vcode_reg_t chars[suffix_len];

457✔

1581

   for (int j = 0; j < suffix_len; j++)

3,734✔

1582

      chars[j] = emit_const(ctype, tb_get(tb)[j]);

3,277✔

1584

   vcode_type_t str_type = vtype_carray(suffix_len, ctype, ctype);

457✔

1585

   vcode_reg_t suffix_reg = emit_const_array(str_type, chars, suffix_len);

457✔

1587

   vcode_reg_t prefix_len_reg = emit_uarray_len(array_reg, 0);

457✔

1588

   vcode_reg_t suffix_len_reg = emit_const(voffset, suffix_len);

457✔

1589

   vcode_reg_t total_len_reg = emit_add(prefix_len_reg, suffix_len_reg);

457✔

1590

   vcode_reg_t mem_reg = emit_alloc(ctype, ctype, total_len_reg);

457✔

1591

   vcode_reg_t suffix_ptr_reg = emit_array_ref(mem_reg, prefix_len_reg);

457✔

1593

   emit_copy(mem_reg, emit_unwrap(array_reg), prefix_len_reg);

457✔

1594

   emit_copy(suffix_ptr_reg, emit_address_of(suffix_reg), suffix_len_reg);

457✔

1596

   vcode_dim_t dim0 = {

457✔

1597

      .left  = emit_const(voffset, 1),

457✔

1599

      .dir   = emit_const(vtype_bool(), RANGE_TO)

457✔

1601

   return emit_wrap(mem_reg, &dim0, 1);

457✔

1604

static vcode_reg_t lower_arith(tree_t fcall, subprogram_kind_t kind,

13,041✔

1607

   type_t type = tree_type(fcall);

13,041✔

1609

   switch (kind) {

13,041✔

1610

   case S_ADD:

3,217✔

1611

      if (type_is_integer(type))

3,217✔

1612

         return emit_trap_add(r0, r1, lower_debug_locus(fcall));

2,857✔

1614

         return emit_add(r0, r1);

360✔

1615

   case S_MUL:

1,630✔

1616

      if (type_is_integer(type))

1,630✔

1617

         return emit_trap_mul(r0, r1, lower_debug_locus(fcall));

902✔

1619

         return emit_mul(r0, r1);

728✔

1620

   case S_SUB:

6,070✔

1621

      if (type_is_integer(type))

6,070✔

1622

         return emit_trap_sub(r0, r1, lower_debug_locus(fcall));

5,756✔

1624

         return emit_sub(r0, r1);

314✔

1625

   case S_MOD: return emit_mod(r0, r1);

198✔

1626

   case S_REM: return emit_rem(r0, r1);

83✔

1627

   case S_DIV: return emit_div(r0, r1);

948✔

1628

   case S_EXP:

895✔

1629

      if (type_is_integer(type))

895✔

1630

         return emit_trap_exp(r0, r1, lower_debug_locus(fcall));

816✔

1632

         return emit_exp(r0, r1);

79✔

1638

static void lower_branch_coverage(lower_unit_t *lu, tree_t b,

332✔

1641

   assert(cover_enabled(lu->cover, COVER_MASK_BRANCH));

332✔

1643

   object_t *obj = tree_to_object(b);

332✔

1645

   cover_scope_t *cs = lower_get_cover_scope(lu);

332✔

1646

   cover_item_t *item = cover_add_items_for(lu->cover, cs, obj,

332✔

1648

   if (item == NULL)

332✔

1649

      return;

12✔

1651

   vcode_block_t blocks[2] = { true_bb, false_bb };

320✔

1653

   for (int i = 0; i < item->consecutive; i++) {

815✔

1654

      assert(blocks[i] != VCODE_INVALID_BLOCK);

495✔

1656

      vcode_select_block(blocks[i]);

495✔

1657

      emit_cover_branch(item[i].tag);

495✔

1661

static void lower_stmt_coverage(lower_unit_t *lu, tree_t stmt)

70,813✔

1663

   if (!cover_enabled(lu->cover, COVER_MASK_STMT))

70,813✔

1666

   cover_scope_t *cs = lower_get_cover_scope(lu);

1,034✔

1667

   cover_item_t *item = cover_add_items_for(lu->cover, cs,

1,034✔

1670

   if (item != NULL)

1,034✔

1671

      emit_cover_stmt(item->tag);

994✔

1674

static void lower_toggle_coverage_cb(lower_unit_t *lu, tree_t field,

27✔

1679

   type_t ftype = tree_type(field);

27✔

1681

   PUSH_COVER_SCOPE(lu, field);

54✔

1683

   if (!type_is_homogeneous(ftype))

27✔

1684

      lower_for_each_field(lu, ftype, field_ptr, locus,

3✔

1687

      cover_scope_t *cscope = lower_get_cover_scope(lu);

24✔

1688

      cover_item_t *first = cover_add_items_for(lu->cover, cscope,

24✔

1691

      if (first != NULL) {

24✔

1692

         vcode_reg_t nets_reg = emit_load_indirect(field_ptr);

21✔

1693

         emit_cover_toggle(nets_reg, first->tag);

21✔

1696

27✔

1698

static void lower_toggle_coverage(lower_unit_t *lu, tree_t decl)

402✔

1700

   assert(cover_enabled(lu->cover, COVER_MASK_TOGGLE));

402✔

1702

   int hops = 0;

402✔

1703

   vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops);

402✔

1704

   assert(var != VCODE_INVALID_VAR);

402✔

1705

   assert(hops == 0);

402✔

1707

   type_t type = tree_type(decl);

402✔

1708

   if (!type_is_homogeneous(type)) {

402✔

1709

      vcode_reg_t rec_ptr = emit_index(var, VCODE_INVALID_REG);

12✔

1710

      lower_for_each_field(lu, type, rec_ptr, VCODE_INVALID_REG,

12✔

1714

      cover_scope_t *cscope = lower_get_cover_scope(lu);

390✔

1715

      cover_item_t *first = cover_add_items_for(lu->cover, cscope,

390✔

1718

      if (first != NULL) {

390✔

1719

         vcode_reg_t nets_reg = emit_load(var);

292✔

1720

         emit_cover_toggle(nets_reg, first->tag);

292✔

1723

402✔

1725

static void lower_state_coverage(lower_unit_t *lu, tree_t decl)

148✔

1727

   assert(cover_enabled(lu->cover, COVER_MASK_STATE));

148✔

1729

   cover_scope_t *cscope = lower_get_cover_scope(lu);

148✔

1731

   int hops = 0;

148✔

1732

   vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops);

148✔

1733

   assert(var != VCODE_INVALID_VAR);

148✔

1735

   cover_item_t *item = cover_add_items_for(lu->cover, cscope,

148✔

1738

   if (item) {

148✔

1739

      vcode_reg_t nets_reg = emit_load(var);

12✔

1745

      vcode_reg_t low_reg = emit_const(vtype_int(INT64_MIN, INT64_MAX),

12✔

1747

      emit_cover_state(nets_reg, low_reg, item->tag);

12✔

1749

148✔

1751

static vcode_reg_t lower_logical(lower_unit_t *lu, tree_t fcall,

23,861✔

1756

   if (!cover_enabled(lu->cover, COVER_MASK_EXPRESSION))

23,861✔

1759

   cover_scope_t *cscope = lower_get_cover_scope(lu);

279✔

1760

   cover_item_t *first = cover_add_items_for(lu->cover, cscope,

279✔

1763

   if (first == NULL)

279✔

1766

   cover_item_t *current = first;

279✔

1768

   vcode_reg_t lhs_n = VCODE_INVALID_REG;

279✔

1769

   vcode_reg_t rhs_n = VCODE_INVALID_REG;

279✔

1771

   if (first->flags & COVER_FLAGS_LHS_RHS_BINS) {

279✔

1772

      lhs_n = emit_not(lhs);

67✔

1773

      rhs_n = emit_not(rhs);

67✔

1776

   struct {

279✔

1780

   } bins[] = {

279✔

1787

   for (int i = 0; i < first->consecutive; i++) {

922✔

1788

      vcode_block_t next_bb = emit_block();

643✔

1789

      vcode_block_t match_bb = emit_block();

643✔

1791

      if (unrc_msk & current->flags)

643✔

1792

         current->flags |= COV_FLAG_UNREACHABLE;

6✔

1795

      if ((current->flags & COV_FLAG_TRUE) || (current->flags & COV_FLAG_FALSE)) {

643✔

1796

         vcode_reg_t test = (current->flags & COV_FLAG_TRUE) ? result : emit_not(result);

424✔

1797

         emit_cond(test, match_bb, next_bb);

424✔

1799

         vcode_select_block(match_bb);

424✔

1800

         emit_cover_expr(current->tag);

424✔

1801

         emit_jump(next_bb);

424✔

1803

         vcode_select_block(next_bb);

424✔

1808

         for (int j = 0; j < ARRAY_LEN(bins); j++) {

555✔

1809

            if (current->flags & bins[j].flag) {

555✔

1810

               vcode_reg_t test = emit_and(bins[j].lhs, bins[j].rhs);

219✔

1811

               emit_cond(test, match_bb, next_bb);

219✔

1813

               vcode_select_block(match_bb);

219✔

1814

               emit_cover_expr(current->tag);

219✔

1815

               emit_jump(next_bb);

219✔

1817

               vcode_select_block(next_bb);

219✔

1818

               break;

219✔

1823

      current++;

643✔

1829

static void lower_logic_expr_coverage(lower_unit_t *lu, tree_t fcall,

121✔

1832

   cover_scope_t *cscope = lower_get_cover_scope(lu);

121✔

1833

   cover_item_t *first = cover_add_items_for(lu->cover, cscope,

121✔

1837

   if (first == NULL)

121✔

1838

      return;

58✔

1840

   vcode_reg_t lhs = args[1];

63✔

1841

   vcode_reg_t rhs = args[2];

63✔

1844

   vcode_type_t vc_logic = vcode_reg_type(lhs);

63✔

1845

   vcode_reg_t log_0 = emit_const(vc_logic, 2);

63✔

1846

   vcode_reg_t log_1 = emit_const(vc_logic, 3);

63✔

1848

   struct {

63✔

1852

   } bins[] = {

63✔

1859

   cover_item_t *current = first;

63✔

1860

   for (int i = 0; i < first->consecutive; i++) {

276✔

1861

      vcode_block_t next_bb = emit_block();

213✔

1862

      vcode_block_t match_bb = emit_block();

213✔

1865

      for (int j = 0; j < ARRAY_LEN(bins); j++) {

1,065✔

1866

         if (current->flags & bins[j].flag) {

852✔

1867

            vcode_reg_t cmp_lhs = emit_cmp(VCODE_CMP_EQ, lhs, bins[j].lhs_exp);

213✔

1868

            vcode_reg_t cmp_rhs = emit_cmp(VCODE_CMP_EQ, rhs, bins[j].rhs_exp);

213✔

1869

            vcode_reg_t test = emit_and(cmp_lhs, cmp_rhs);

213✔

1871

            emit_cond(test, match_bb, next_bb);

213✔

1873

            vcode_select_block(match_bb);

213✔

1874

            emit_cover_expr(current->tag);

213✔

1875

            emit_jump(next_bb);

213✔

1877

            vcode_select_block(next_bb);

213✔

1881

      current++;

213✔

1886

static bool lower_side_effect_free(tree_t expr)

17,495✔

1889

   switch (tree_kind(expr)) {

17,722✔

1894

   case T_FCALL:

5,686✔

1896

         const subprogram_kind_t kind = tree_subkind(tree_ref(expr));

5,686✔

1897

         if (kind == S_DIV || kind == S_DIV_PR || kind == S_DIV_RI

5,686✔

1898

             || kind == S_REM || kind == S_MOD)

5,677✔

1900

         else if (kind == S_CONCAT)

5,677✔

1902

         else if (kind == S_USER || !is_open_coded_builtin(kind))

5,287✔

1903

            return false;

1,418✔

1905

         const int nparams = tree_params(expr);

3,869✔

1906

         for (int i = 0; i < nparams; i++) {

7,783✔

1907

            if (!lower_side_effect_free(tree_value(tree_param(expr, i))))

5,874✔

1913

      break;

199✔

1914

   case T_RECORD_REF:

199✔

1917

      return lower_side_effect_free(tree_value(expr));

199✔

1918

   case T_ATTR_REF:

581✔

1920

         const attr_kind_t kind = tree_subkind(expr);

581✔

1921

         if (kind == ATTR_EVENT || kind == ATTR_ACTIVE)

581✔

1922

            return lower_side_effect_free(tree_name(expr));

28✔

1926

   default:

1,295✔

1927

      return false;

1,295✔

1931

static vcode_var_t lower_temp_var(lower_unit_t *lu, const char *prefix,

9,690✔

1934

   vcode_var_t tmp = VCODE_INVALID_VAR;

9,690✔

1935

   unsigned pos = 0;

9,690✔

1936

   for (; pos < lu->free_temps.count; pos++) {

9,934✔

1937

      tmp = lu->free_temps.items[pos];

3,992✔

1938

      if (vtype_eq(vcode_var_type(tmp), vtype)

3,992✔

1939

          && vtype_eq(vcode_var_bounds(tmp), vbounds))

3,751✔

1943

   if (pos == lu->free_temps.count)

9,690✔

1944

      return emit_var(vtype, vbounds, ident_uniq("%s", prefix), VAR_TEMP);

5,942✔

1946

   emit_comment("Reusing temp var %s", istr(vcode_var_name(tmp)));

3,748✔

1948

   for (; pos < lu->free_temps.count - 1; pos++)

7,728✔

1949

      lu->free_temps.items[pos] = lu->free_temps.items[pos + 1];

232✔

1950

   APOP(lu->free_temps);

3,748✔

1952

   return tmp;

3,748✔

1955

static void lower_release_temp(lower_unit_t *lu, vcode_var_t tmp)

6,419✔

1957

   assert(vcode_var_flags(tmp) & VAR_TEMP);

6,419✔

1958

   APUSH(lu->free_temps, tmp);

6,419✔

1959

6,419✔

1961

static vcode_reg_t lower_short_circuit(lower_unit_t *lu, tree_t fcall,

5,019✔

1964

   vcode_reg_t r0 = lower_subprogram_arg(lu, fcall, 0);

5,019✔

1965

   int64_t value;

5,019✔

1966

   if (vcode_reg_const(r0, &value)) {

5,019✔

1967

      vcode_reg_t result = VCODE_INVALID_REG;

148✔

1968

      switch (builtin) {

148✔

1969

      case S_SCALAR_AND:

79✔

1970

         result = value ? lower_subprogram_arg(lu, fcall, 1) : r0;

79✔

1972

      case S_SCALAR_OR:

68✔

1973

         result = value ? r0 : lower_subprogram_arg(lu, fcall, 1);

68✔

1975

      case S_SCALAR_NOR:

1✔

1976

         result = emit_not(value ? r0 : lower_subprogram_arg(lu, fcall, 1));

1✔

1977

         break;

1✔

1986

      return result;

148✔

1989

   if (lower_side_effect_free(tree_value(tree_param(fcall, 1)))) {

4,871✔

1990

      vcode_reg_t r1 = lower_subprogram_arg(lu, fcall, 1);

1,842✔

1991

      switch (builtin) {

1,842✔

1992

      case S_SCALAR_AND:

1,197✔

1993

         return lower_logical(lu, fcall, emit_and(r0, r1), r0, r1, builtin, 0);

1,197✔

1994

      case S_SCALAR_OR:

571✔

1995

         return lower_logical(lu, fcall, emit_or(r0, r1), r0, r1, builtin, 0);

571✔

1996

      case S_SCALAR_NOR:

37✔

1997

         return lower_logical(lu, fcall, emit_nor(r0, r1), r0, r1, builtin, 0);

37✔

1998

      case S_SCALAR_NAND:

37✔

1999

         return lower_logical(lu, fcall, emit_nand(r0, r1), r0, r1, builtin, 0);

37✔

2006

   vcode_block_t arg1_bb = emit_block();

3,029✔

2007

   vcode_block_t after_bb = emit_block();

3,029✔

2009

   vcode_type_t vbool = vtype_bool();

3,029✔

2010

   vcode_var_t tmp_var = lower_temp_var(lu, "shortcircuit", vbool, vbool);

3,029✔

2012

   if (builtin == S_SCALAR_NOR || builtin == S_SCALAR_NAND)

3,029✔

2013

      emit_store(emit_not(r0), tmp_var);

25✔

2015

      emit_store(r0, tmp_var);

3,004✔

2017

   if (builtin == S_SCALAR_AND || builtin == S_SCALAR_NAND)

3,029✔

2018

      emit_cond(r0, arg1_bb, after_bb);

2,244✔

2020

      emit_cond(r0, after_bb, arg1_bb);

785✔

2022

   vcode_select_block(arg1_bb);

3,029✔

2023

   vcode_reg_t r1 = lower_subprogram_arg(lu, fcall, 1);

3,029✔

2025

   switch (builtin) {

3,029✔

2026

   case S_SCALAR_AND:

2,232✔

2027

      emit_store(emit_and(r0, r1), tmp_var);

2,232✔

2028

      break;

2,232✔

2029

   case S_SCALAR_OR:

772✔

2030

      emit_store(emit_or(r0, r1), tmp_var);

772✔

2031

      break;

772✔

2032

   case S_SCALAR_NOR:

13✔

2033

      emit_store(emit_nor(r0, r1), tmp_var);

13✔

2034

      break;

13✔

2035

   case S_SCALAR_NAND:

12✔

2036

      emit_store(emit_nand(r0, r1), tmp_var);

12✔

2037

      break;

12✔

2044

   unsigned unrc_msk = 0;

3,029✔

2045

   if (cover_enabled(lu->cover, COVER_MASK_EXCLUDE_UNREACHABLE)) {

3,029✔

2046

      if (builtin == S_SCALAR_AND || builtin == S_SCALAR_NAND)

6✔

2049

         unrc_msk = COV_FLAG_11 | COV_FLAG_10;

3✔

2053

   lower_logical(lu, fcall, emit_load(tmp_var), r0, r1, builtin, unrc_msk);

3,029✔

2055

   emit_jump(after_bb);

3,029✔

2057

   vcode_select_block(after_bb);

3,029✔

2058

   vcode_reg_t result = emit_load(tmp_var);

3,029✔

2059

   lower_release_temp(lu, tmp_var);

3,029✔

2061

   return result;

3,029✔

2064

static void lower_flatten_concat(lower_unit_t *lu, tree_t arg,

3,430✔

2067

   if (tree_kind(arg) == T_FCALL && tree_subkind(tree_ref(arg)) == S_CONCAT) {

5,609✔

2068

      assert(tree_params(arg) == 2);

2,179✔

2069

      lower_flatten_concat(lu, tree_value(tree_param(arg, 0)), list);

2,179✔

2070

      lower_flatten_concat(lu, tree_value(tree_param(arg, 1)), list);

2,179✔

2073

      vcode_reg_t reg = lower_rvalue(lu, arg);

3,430✔

2074

      APUSH(*list, ((concat_param_t){ arg, tree_type(arg), reg }));

3,430✔

2076

3,430✔

2078

static vcode_reg_t lower_concat(lower_unit_t *lu, tree_t expr, vcode_reg_t hint,

1,251✔

2081

   assert(tree_params(expr) == 2);

1,251✔

2083

   concat_list_t args = AINIT;

1,251✔

2084

   lower_flatten_concat(lu, expr, &args);

1,251✔

2086

   type_t type = tree_type(expr);

1,251✔

2087

   type_t elem = type_elem(type);

1,251✔

2088

   assert(type_is_unconstrained(type));

1,251✔

2090

   type_t scalar_elem = type_elem_recur(elem);

1,251✔

2092

   vcode_type_t voffset = vtype_offset();

1,251✔

2094

   type_t index_type = index_type_of(type, 0);

1,251✔

2095

   tree_t index_r = range_of(index_type, 0);

1,251✔

2096

   vcode_type_t itype = lower_type(index_type);

1,251✔

2097

   vcode_type_t ibounds = lower_bounds(index_type);

1,251✔

2099

   vcode_reg_t len   = emit_const(voffset, 0);

1,251✔

2100

   vcode_reg_t elems = emit_const(voffset, -1);

1,251✔

2101

   vcode_reg_t dir   = lower_range_dir(lu, index_r);

1,251✔

2102

   vcode_reg_t left  = lower_range_left(lu, index_r);

1,251✔

2104

   for (unsigned i = 0; i < args.count; i++) {

4,681✔

2105

      concat_param_t *p = &(args.items[i]);

3,430✔

2106

      if (type_is_array(p->type) && type_eq(p->type, type)) {

3,430✔

2107

         elems = emit_add(elems, lower_array_len(lu, p->type, 0, p->reg));

3,064✔

2108

         len   = emit_add(len, lower_array_total_len(lu, p->type, p->reg));

3,064✔

2111

         vcode_reg_t one_reg = emit_const(vtype_offset(), 1);

366✔

2112

         elems = emit_add(elems, one_reg);

366✔

2113

         len   = emit_add(len, one_reg);

366✔

2117

   vcode_reg_t mem_reg;

1,251✔

2118

   if (hint != VCODE_INVALID_REG && len == hint_count)

1,251✔

2121

      mem_reg = emit_alloc(lower_type(scalar_elem),

1,185✔

2124

   vcode_reg_t cast_reg   = emit_cast(itype, ibounds, elems);

1,251✔

2125

   vcode_reg_t right_to   = emit_add(left, cast_reg);

1,251✔

2126

   vcode_reg_t right_down = emit_sub(left, cast_reg);

1,251✔

2127

   vcode_reg_t right      = emit_select(dir, right_down, right_to);

1,251✔

2129

   vcode_dim_t dims[1] = { { left, right, dir } };

1,251✔

2130

   vcode_reg_t var_reg = emit_wrap(mem_reg, dims, 1);

1,251✔

2132

   vcode_reg_t off_reg = emit_const(voffset, 0);

1,251✔

2133

   for (unsigned i = 0; i < args.count; i++) {

4,681✔

2134

      concat_param_t *p = &(args.items[i]);

3,430✔

2135

      vcode_reg_t ptr = emit_array_ref(mem_reg, off_reg);

3,430✔

2136

      if (type_is_array(p->type)) {

3,430✔

2137

         vcode_reg_t src_len = lower_array_total_len(lu, p->type, p->reg);

3,067✔

2139

         vcode_reg_t data_reg;

3,067✔

2140

         if (lower_have_signal(p->reg))

3,067✔

2143

            data_reg = lower_array_data(p->reg);

3,067✔

2145

         emit_copy(ptr, data_reg, src_len);

3,067✔

2146

         if (i + 1 < args.count)

3,067✔

2147

            off_reg = emit_add(off_reg, src_len);

1,912✔

2149

      else if (type_is_record(p->type)) {

363✔

2150

         emit_copy(ptr, p->reg, VCODE_INVALID_REG);

12✔

2151

         if (i + 1 < args.count)

12✔

2152

            off_reg = emit_add(off_reg, emit_const(vtype_offset(), 1));

6✔

2155

         emit_store_indirect(p->reg, ptr);

351✔

2156

         if (i + 1 < args.count)

351✔

2157

            off_reg = emit_add(off_reg, emit_const(vtype_offset(), 1));

261✔

2161

   ACLEAR(args);

1,251✔

2162

   return var_reg;

1,251✔

2165

static vcode_reg_t lower_comparison(lower_unit_t *lu, tree_t fcall,

17,453✔

2169

   vcode_cmp_t cmp;

17,453✔

2170

   switch (builtin) {

17,453✔

2181

   vcode_reg_t result = emit_cmp(cmp, r0, r1);

17,453✔

2182

   return lower_logical(lu, fcall, result, r0, r1, builtin, 0);

17,453✔

2185

static vcode_reg_t lower_builtin(lower_unit_t *lu, tree_t fcall,

45,908✔

2189

   if (builtin == S_SCALAR_AND || builtin == S_SCALAR_OR ||

45,908✔

2190

       builtin == S_SCALAR_NOR || builtin == S_SCALAR_NAND)

45,908✔

2191

      return lower_short_circuit(lu, fcall, builtin);

5,019✔

2192

   else if (builtin == S_CONCAT)

40,889✔

2193

      return lower_concat(lu, fcall, VCODE_INVALID_REG, VCODE_INVALID_REG);

1,170✔

2195

   vcode_reg_t r0 = lower_subprogram_arg(lu, fcall, 0);

39,719✔

2196

   vcode_reg_t r1 = lower_subprogram_arg(lu, fcall, 1);

39,719✔

2198

   if (out_r0 != NULL) *out_r0 = r0;

39,719✔

2199

   if (out_r1 != NULL) *out_r1 = r1;

39,719✔

2201

   type_t r0_type = lower_arg_type(fcall, 0);

39,719✔

2202

   type_t r1_type = lower_arg_type(fcall, 1);

39,719✔

2204

   switch (builtin) {

39,719✔

2205

   case S_SCALAR_EQ:

17,453✔

2211

      return lower_comparison(lu, fcall, builtin, r0, r1);

17,453✔

2212

   case S_MOD:

1,229✔

2215

      if (type_is_integer(r1_type)) {

1,229✔

2216

         vcode_reg_t locus = lower_debug_locus(fcall);

1,006✔

2217

         emit_zero_check(r1, locus);

1,006✔

2223

      return lower_arith(fcall, builtin, r0, r1);

12,146✔

2224

   case S_EXP:

895✔

2226

         if (type_is_integer(r0_type)) {

895✔

2227

            vcode_reg_t locus = lower_debug_locus(fcall);

816✔

2228

            emit_exponent_check(r1, locus);

816✔

2231

         if (!type_eq(r0_type, r1_type))

895✔

2232

            r1 = emit_cast(lower_type(r0_type), lower_bounds(r0_type), r1);

98✔

2234

         return lower_arith(fcall, S_EXP, r0, r1);

895✔

2236

   case S_NEGATE:

6,727✔

2238

         if (type_is_integer(r0_type)) {

6,727✔

2239

            vcode_reg_t locus = lower_debug_locus(fcall);

785✔

2240

            return emit_trap_neg(r0, locus);

785✔

2243

            return emit_neg(r0);

5,942✔

2245

   case S_ABS:

237✔

2246

      return emit_abs(r0);

237✔

2249

   case S_SCALAR_NOT:

1,406✔

2250

      return lower_logical(lu, fcall, emit_not(r0), r0, 0, builtin, 0);

1,406✔

2251

   case S_SCALAR_XOR:

76✔

2252

      return lower_logical(lu, fcall, emit_xor(r0, r1), r0, r1, builtin, 0);

76✔

2253

   case S_SCALAR_XNOR:

55✔

2254

      return lower_logical(lu, fcall, emit_xnor(r0, r1), r0, r1, builtin, 0);

55✔

2255

   case S_FILE_OPEN1:

138✔

2257

         vcode_reg_t name   = lower_array_data(r1);

138✔

2258

         vcode_reg_t length = lower_array_len(lu, r1_type, 0, r1);

138✔

2259

         vcode_reg_t kind   = lower_subprogram_arg(lu, fcall, 2);

138✔

2260

         emit_file_open(r0, name, length, kind, VCODE_INVALID_REG);

138✔

2261

         return VCODE_INVALID_REG;

138✔

2263

   case S_FILE_OPEN2:

22✔

2265

         type_t arg_type = lower_arg_type(fcall, 2);

22✔

2266

         vcode_reg_t r2     = lower_subprogram_arg(lu, fcall, 2);

22✔

2267

         vcode_reg_t name   = lower_array_data(r2);

22✔

2268

         vcode_reg_t length = lower_array_len(lu, arg_type, 0, r2);

22✔

2269

         vcode_reg_t kind   = lower_subprogram_arg(lu, fcall, 3);

22✔

2270

         emit_file_open(r1, name, length, kind, r0);

22✔

2271

         return VCODE_INVALID_REG;

22✔

2273

   case S_FILE_WRITE:

125✔

2275

         vcode_reg_t length = VCODE_INVALID_REG;

125✔

2276

         vcode_reg_t data   = r1;

125✔

2277

         if (type_is_array(r1_type)) {

125✔

2278

            length = lower_array_total_len(lu, r1_type, r1);

68✔

2279

            data   = lower_array_data(r1);

68✔

2281

         emit_file_write(r0, data, length);

125✔

2282

         return VCODE_INVALID_REG;

125✔

2284

   case S_FILE_READ:

75✔

2286

         vcode_reg_t inlen = VCODE_INVALID_REG;

75✔

2287

         if (type_is_array(r1_type))

75✔

2288

            inlen = lower_array_total_len(lu, r1_type, r1);

27✔

2290

         vcode_reg_t outlen = VCODE_INVALID_REG;

75✔

2291

         if (tree_params(fcall) == 3)

75✔

2292

            outlen = lower_subprogram_arg(lu, fcall, 2);

18✔

2294

         emit_file_read(r0, r1, inlen, outlen);

75✔

2295

         return VCODE_INVALID_REG;

75✔

2297

   case S_DEALLOCATE:

207✔

2298

      emit_deallocate(r0);

207✔

2299

      return VCODE_INVALID_REG;

207✔

2300

   case S_MUL_RP:

4✔

2303

         vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX);

4✔

2304

         vcode_type_t rtype = lower_type(tree_type(fcall));

4✔

2305

         return emit_cast(rtype, rtype,

4✔

2308

   case S_MUL_PR:

7✔

2311

         vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX);

7✔

2312

         vcode_type_t rtype = lower_type(tree_type(fcall));

7✔

2313

         return emit_cast(rtype, rtype,

7✔

2316

   case S_MUL_IP:

53✔

2318

         vcode_type_t rtype = lower_type(tree_type(fcall));

53✔

2319

         vcode_reg_t cast_reg = emit_cast(rtype, rtype, r0);

53✔

2320

         return emit_mul(cast_reg, r1);

53✔

2322

   case S_MUL_PI:

18✔

2324

         vcode_type_t rtype = lower_type(tree_type(fcall));

18✔

2325

         vcode_reg_t cast_reg = emit_cast(rtype, rtype, r1);

18✔

2326

         return emit_mul(r0, cast_reg);

18✔

2328

   case S_DIV_PR:

7✔

2330

         vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX);

7✔

2331

         vcode_type_t rtype = lower_type(tree_type(fcall));

7✔

2332

         return emit_cast(rtype, rtype,

7✔

2335

   case S_DIV_RI:

1✔

2337

         vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX);

1✔

2338

         vcode_type_t rtype = lower_type(tree_type(fcall));

1✔

2339

         vcode_reg_t locus = lower_debug_locus(fcall);

1✔

2340

         emit_zero_check(r1, locus);

1✔

2341

         return emit_cast(rtype, rtype,

1✔

2344

   case S_DIV_PP:

12✔

2346

         vcode_reg_t locus = lower_debug_locus(fcall);

12✔

2347

         emit_zero_check(r1, locus);

12✔

2348

         vcode_reg_t div_reg = emit_div(r0, r1);

12✔

2349

         vcode_type_t rtype = lower_type(tree_type(fcall));

12✔

2350

         return emit_cast(rtype, rtype, div_reg);

12✔

2352

   case S_DIV_PI:

48✔

2354

         vcode_reg_t locus = lower_debug_locus(fcall);

48✔

2355

         emit_zero_check(r1, locus);

48✔

2356

         vcode_type_t rtype = lower_type(tree_type(fcall));

48✔

2357

         vcode_reg_t cast_reg = emit_cast(rtype, rtype, r1);

48✔

2358

         return emit_div(r0, cast_reg);

48✔

2365

static vcode_type_t lower_func_result_type(type_t result)

52,568✔

2367

   if (type_is_array(result) && type_const_bounds(result))

52,568✔

2368

      return vtype_pointer(lower_type(type_elem_recur(result)));

443✔

2369

   else if (type_is_record(result))

52,125✔

2370

      return vtype_pointer(lower_type(result));

1,848✔

2372

      return lower_type(result);

50,277✔

2375

static vcode_type_t lower_param_type(type_t type, class_t class,

18,353✔

2378

   switch (class) {

18,353✔

2379

   case C_SIGNAL:

665✔

2380

      if (type_is_homogeneous(type))

665✔

2381

         return lower_signal_type(type);

229✔

2382

      else if (type_is_array(type)) {

436✔

2383

         if (type_const_bounds(type))

113✔

2384

            return vtype_pointer(lower_signal_type(type_elem_recur(type)));

9✔

2386

            return lower_signal_type(type);

104✔

2389

         return vtype_pointer(lower_signal_type(type));

323✔

2391

   case C_VARIABLE:

17,568✔

2395

         if (type_is_array(type)) {

17,568✔

2396

            if (type_const_bounds(type))

9,311✔

2397

               return vtype_pointer(lower_type(type_elem_recur(type)));

197✔

2399

               return lower_type(type);

9,114✔

2401

         else if (type_is_record(type))

8,257✔

2402

            return vtype_pointer(lower_type(type));

1,047✔

2403

         else if (mode == PORT_OUT || mode == PORT_INOUT)

7,210✔

2404

            return vtype_pointer(lower_type(type));

910✔

2406

            return lower_type(type);

6,300✔

2408

      break;

120✔

2410

   case C_FILE:

120✔

2411

      return vtype_pointer(lower_type(type));

120✔

2418

static vcode_reg_t lower_context_for_call(lower_unit_t *lu, ident_t unit_name)

38,479✔

2421

   if (lu->registry != NULL && unit_registry_query(lu->registry, unit_name)) {

38,479✔

2422

      vcode_unit_t vu = unit_registry_get(lu->registry, unit_name);

21,357✔

2424

      vcode_unit_t context = vcode_unit_context(vu);

21,357✔

2425

      assert(context != NULL);

21,357✔

2427

      vcode_unit_t ancestor = lu->vunit;

21,357✔

2428

      int hops = 0;

21,357✔

2429

      for (; ancestor && ancestor != context;

47,535✔

2430

           hops++, ancestor = vcode_unit_context(ancestor))

26,178✔

2433

      if (ancestor != NULL)

21,357✔

2434

         return emit_context_upref(hops);

15,479✔

2435

      else if (vcode_unit_kind(context) == VCODE_UNIT_PACKAGE) {

5,878✔

2436

         ident_t context_name = vcode_unit_name(context);

5,877✔

2437

         if (vcode_unit_kind(lu->vunit) == VCODE_UNIT_THUNK)

5,877✔

2438

            return emit_package_init(context_name, VCODE_INVALID_REG);

877✔

2440

            return emit_link_package(context_name);

5,000✔

2444

   int hops = 0;

17,123✔

2445

   for (vcode_unit_t it = lu->vunit; ; hops++) {

17,123✔

2446

      ident_t this = vcode_unit_name(it);

33,371✔

2447

      assert(this != unit_name);

33,371✔

2448

      if (ident_starts_with(unit_name, this)

33,371✔

2449

          && ident_char(unit_name, ident_len(this)) == '.')

2✔

2452

      vcode_unit_t context = vcode_unit_context(it);

33,371✔

2453

      if (context == NULL)

33,371✔

2456

      it = context;

16,248✔

2459

   ident_t it = unit_name;

17,123✔

2460

   ident_t lname = ident_walk_selected(&it);

17,123✔

2461

   ident_t uname = ident_walk_selected(&it);

17,123✔

2463

   lib_t lib = lib_require(lname);

17,123✔

2465

   ident_t base_name = ident_prefix(lname, uname, '.');

17,123✔

2466

   tree_t unit = lib_get(lib, base_name);

17,123✔

2467

   if (unit == NULL)

17,123✔

2470

   const tree_kind_t kind = tree_kind(unit);

17,123✔

2471

   if (kind == T_ENTITY || kind == T_ARCH) {

17,123✔

2473

      return emit_null(vtype_context(unit_name));

1✔

2476

   assert(is_package(unit));

17,122✔

2477

   assert(!is_uninstantiated_package(unit));

17,122✔

2479

   vcode_reg_t pack_reg;

17,122✔

2480

   if (vcode_unit_kind(lu->vunit) == VCODE_UNIT_THUNK)

17,122✔

2481

      pack_reg = emit_package_init(base_name, VCODE_INVALID_REG);

2,194✔

2483

      pack_reg = emit_link_package(base_name);

14,928✔

2485

   for (;;) {

3✔

2487

      ident_t var_name = ident_walk_selected(&it);

17,125✔

2488

      if (it == NULL || ident_pos(var_name, '(') != -1)

17,125✔

2489

         return pack_reg;

17,122✔

2491

      ident_t qual = ident_prefix(base_name, var_name, '.');

3✔

2492

      vcode_reg_t var_reg = emit_link_var(pack_reg, qual, vtype_context(qual));

3✔

2493

      pack_reg = emit_load_indirect(var_reg);

3✔

2494

      base_name = qual;

3✔

2498

static vcode_reg_t lower_fcall(lower_unit_t *lu, tree_t fcall,

65,978✔

2501

   tree_t decl = tree_ref(fcall);

65,978✔

2503

   const subprogram_kind_t kind = tree_subkind(decl);

65,978✔

2504

   if (is_open_coded_builtin(kind))

65,978✔

2505

      return lower_builtin(lu, fcall, kind, NULL, NULL);

39,455✔

2507

   const int nparams = tree_params(fcall);

26,523✔

2508

   SCOPED_A(vcode_reg_t) args = AINIT;

53,046✔

2510

   ident_t name = tree_ident2(decl);

26,523✔

2512

   if (tree_kind(fcall) == T_PROT_FCALL && tree_has_name(fcall))

26,523✔

2513

      APUSH(args, lower_rvalue(lu, tree_name(fcall)));

780✔

2515

      APUSH(args, lower_context_for_call(lu, name));

25,743✔

2517

   for (int i = 0; i < nparams; i++) {

76,387✔

2518

      vcode_reg_t arg_reg = lower_subprogram_arg(lu, fcall, i);

49,864✔

2519

      APUSH(args, arg_reg);

49,864✔

2522

   if (bounds_reg != VCODE_INVALID_REG)

26,523✔

2523

      APUSH(args, bounds_reg);

39✔

2525

   type_t result = tree_type(fcall);

26,523✔

2526

   vcode_type_t rtype = lower_func_result_type(result);

26,523✔

2527

   vcode_type_t rbounds = lower_bounds(result);

26,523✔

2529

   if (cover_enabled(lu->cover, COVER_MASK_EXPRESSION))

26,523✔

2530

      lower_logic_expr_coverage(lu, fcall, args.items);

121✔

2532

   return emit_fcall(name, rtype, rbounds, args.items, args.count);

26,523✔

2535

static vcode_reg_t lower_known_subtype(lower_unit_t *lu, tree_t value,

12,151✔

2538

   if (tree_kind(value) != T_FCALL)

12,151✔

2539

      return lower_rvalue(lu, value);

7,783✔

2541

   tree_t decl = tree_ref(value);

4,368✔

2542

   if (!(tree_flags(decl) & TREE_F_KNOWS_SUBTYPE))

4,368✔

2543

      return lower_rvalue(lu, value);

4,329✔

2545

   if (type_is_array(type)) {

39✔

2546

      if (bounds_reg == VCODE_INVALID_REG

21✔

2547

          || vcode_reg_kind(bounds_reg) != VCODE_TYPE_UARRAY) {

15✔

2548

         vcode_type_t velem = lower_type(type_elem_recur(type));

21✔

2549

         vcode_reg_t null_reg = emit_null(vtype_pointer(velem));

21✔

2550

         bounds_reg = lower_wrap(lu, type, null_reg);

21✔

2553

   else if (type_is_record(type)) {

18✔

2554

      if (bounds_reg == VCODE_INVALID_REG) {

18✔

2556

         bounds_reg = lower_default_value(lu, type, VCODE_INVALID_REG);

6✔

2558

      else if (vtype_is_signal(vcode_reg_type(bounds_reg)))

12✔

2559

         bounds_reg = lower_resolved(lu, type, bounds_reg);

6✔

2562

   return lower_fcall(lu, value, bounds_reg);

39✔

2565

static vcode_reg_t *lower_string_literal_chars(tree_t lit, int *nchars)

20,434✔

2567

   type_t ltype = tree_type(lit);

20,434✔

2568

   vcode_type_t vtype = lower_type(type_elem(ltype));

20,434✔

2570

   *nchars = tree_chars(lit);

20,434✔

2571

   vcode_reg_t *tmp = xmalloc_array(*nchars, sizeof(vcode_reg_t));

20,434✔

2573

   for (int i = 0; i < *nchars; i++)

277,141✔

2574

      tmp[i] = emit_const(vtype, assume_int(tree_char(lit, i)));

256,707✔

2576

   return tmp;

20,434✔

2579

static vcode_reg_t lower_string_literal(tree_t lit, bool nest)

20,052✔

2581

   int nchars;

20,052✔

2582

   vcode_reg_t *tmp LOCAL = lower_string_literal_chars(lit, &nchars);

40,104✔

2584

   type_t type = tree_type(lit);

20,052✔

2585

   vcode_type_t elem = lower_type(type_elem(type));

20,052✔

2586

   vcode_type_t array_type = vtype_carray(nchars, elem, elem);

20,052✔

2588

   vcode_reg_t array_reg = emit_const_array(array_type, tmp, nchars);

20,052✔

2590

   if (type_is_array(type) && !type_const_bounds(type)) {

20,052✔

2598

   else if (nest)

20,052✔

2601

      return emit_address_of(array_reg);

19,740✔

2604

static vcode_reg_t lower_literal(tree_t lit)

178,947✔

2606

   switch (tree_subkind(lit)) {

178,947✔

2607

   case L_PHYSICAL:

7,809✔

2608

      assert(!tree_has_ref(lit));

7,809✔

2611

      return emit_const(lower_type(tree_type(lit)), tree_ival(lit));

152,512✔

2613

   case L_NULL:

132✔

2614

      return emit_null(lower_type(tree_type(lit)));

132✔

2616

   case L_REAL:

26,303✔

2617

      return emit_const_real(lower_type(tree_type(lit)), tree_dval(lit));

26,303✔

2625

int lower_search_vcode_obj(void *key, lower_unit_t *scope, int *hops)

156,760✔

2627

   *hops = 0;

156,760✔

2628

   for (; scope != NULL; scope = scope->parent) {

233,554✔

2629

      const void *ptr = hash_get(scope->objects, key);

227,930✔

2630

      const int obj = (uintptr_t)ptr - 1;

227,930✔

2631

      if (obj != VCODE_INVALID_REG)

227,930✔

2632

         return obj;

151,136✔

2633

      (*hops)++;

76,794✔

2636

   *hops = 0;

5,624✔

2637

   return VCODE_INVALID_REG;

5,624✔

2640

void lower_put_vcode_obj(void *key, int obj, lower_unit_t *scope)

60,520✔

2642

   hash_put(scope->objects, key, (void *)(uintptr_t)(obj + 1));

60,520✔

2643

60,520✔

2645

static vcode_var_t lower_get_var(lower_unit_t *lu, tree_t decl, int *hops)

58,542✔

2647

   return lower_search_vcode_obj(decl, lu, hops);

58,542✔

2650

static vcode_reg_t lower_get_type_bounds(lower_unit_t *lu, type_t type)

7,022✔

2652

   assert(!type_is_unconstrained(type));

7,022✔

2654

   if (type_is_record(type))

7,022✔

2656

   else if (type_is_scalar(type)) {

6,864✔

2657

      vcode_reg_t left_reg, right_reg, dir_reg;

496✔

2658

      lower_get_scalar_type_bounds(lu, type, &left_reg, &right_reg, &dir_reg);

496✔

2660

      vcode_dim_t dims[1] = { { left_reg, right_reg, dir_reg } };

496✔

2662

      vcode_reg_t null_reg = emit_null(vtype_pointer(lower_type(type)));

496✔

2663

      return emit_wrap(null_reg, dims, 1);

496✔

2665

   else if (type_has_ident(type)) {

6,368✔

2666

      int hops = 0;

1,155✔

2667

      vcode_var_t var = lower_search_vcode_obj(type, lu, &hops);

1,155✔

2668

      if (var == VCODE_INVALID_VAR) {

1,155✔

2670

         ident_t id = type_ident(type);

32✔

2671

         vcode_reg_t context = emit_link_package(ident_runtil(id, '.'));

32✔

2672

         vcode_reg_t ptr_reg = emit_link_var(context, id, lower_type(type));

32✔

2673

         return emit_load_indirect(ptr_reg);

32✔

2675

      else if (hops == 0)

1,123✔

2676

         return emit_load(var);

855✔

2678

         vcode_reg_t ptr_reg = emit_var_upref(hops, var);

268✔

2679

         return emit_load_indirect(ptr_reg);

268✔

2682

   else {

5,213✔

2683

      vcode_type_t vtype = lower_type(type);

5,213✔

2684

      assert(vtype_kind(vtype) == VCODE_TYPE_UARRAY);

5,213✔

2686

      const int ndims = vtype_dims(vtype);

5,213✔

2687

      int dptr = 0;

5,213✔

2688

      vcode_dim_t dims[ndims];

5,213✔

2690

      const int tdims = dimension_of(type);

5,213✔

2691

      for (int i = 0; i < tdims; i++, dptr++) {

10,447✔

2692

         tree_t r = range_of(type, i);

5,234✔

2693

         dims[dptr].left  = lower_range_left(lu, r);

5,234✔

2694

         dims[dptr].right = lower_range_right(lu, r);

5,234✔

2695

         dims[dptr].dir   = lower_range_dir(lu, r);

5,234✔

2698

      if (dptr < ndims) {

5,213✔

2699

         type_t elem = type_elem(type);

41✔

2700

         vcode_reg_t bounds_reg = lower_get_type_bounds(lu, elem);

41✔

2701

         assert(dptr + vtype_dims(vcode_reg_type(bounds_reg)) == ndims);

41✔

2703

         for (int i = 0; dptr < ndims; i++, dptr++) {

82✔

2704

            dims[dptr].left  = emit_uarray_left(bounds_reg, i);

41✔

2705

            dims[dptr].right = emit_uarray_right(bounds_reg, i);

41✔

2706

            dims[dptr].dir   = emit_uarray_dir(bounds_reg, i);

41✔

2710

      vcode_reg_t null_reg = emit_null(vtype_pointer(vtype_elem(vtype)));

5,213✔

2711

      return emit_wrap(null_reg, dims, ndims);

5,213✔

2715

static vcode_type_t lower_var_type(tree_t decl)

5,129✔

2717

   if (tree_kind(decl) == T_ALIAS)

5,129✔

2718

      return lower_alias_type(decl);

10✔

2720

      type_t type = tree_type(decl);

5,119✔

2721

      if (class_of(decl) == C_SIGNAL)

5,119✔

2722

         return lower_signal_type(type);

2,257✔

2723

      else if (type_is_array(type) && type_const_bounds(type))

2,862✔

2724

         return lower_type(type_elem_recur(type));

1,766✔

2726

         return lower_type(type);

1,096✔

2730

static vcode_reg_t lower_link_var(lower_unit_t *lu, tree_t decl)

5,091✔

2732

   tree_t container = tree_container(decl);

5,091✔

2733

   const tree_kind_t kind = tree_kind(container);

5,091✔

2734

   vcode_reg_t context = VCODE_INVALID_REG;

5,091✔

2735

   vcode_type_t vtype = lower_var_type(decl);

5,091✔

2737

   if (kind != T_PACKAGE && kind != T_PACK_INST) {

5,091✔

2738

      if (lu->mode == LOWER_THUNK)

1,442✔

2739

         return emit_undefined(vtype_pointer(vtype), vtype);

1,442✔

2746

   else if (lu->mode == LOWER_THUNK && container == lu->container) {

3,649✔

2749

      assert(tree_kind(decl) == T_CONST_DECL);

9✔

2751

      if (tree_has_value(decl)) {

9✔

2752

         tree_t value = tree_value(decl);

9✔

2753

         if (lower_is_const(value))

9✔

2754

            return lower_rvalue(lu, value);

9✔

2760

   assert(!is_uninstantiated_package(container));

3,640✔

2762

   if (lu->mode == LOWER_THUNK)

3,640✔

2763

      context = emit_package_init(tree_ident(container), VCODE_INVALID_REG);

33✔

2765

      context = emit_link_package(tree_ident(container));

3,607✔

2767

   return emit_link_var(context, tree_ident(decl), vtype);

3,640✔

2770

static vcode_reg_t lower_var_ref(lower_unit_t *lu, tree_t decl, expr_ctx_t ctx)

48,008✔

2772

   type_t type = tree_type(decl);

48,008✔

2774

   vcode_reg_t ptr_reg = VCODE_INVALID_REG;

48,008✔

2775

   int hops = 0;

48,008✔

2776

   vcode_var_t var = lower_get_var(lu, decl, &hops);

48,008✔

2777

   if (var == VCODE_INVALID_VAR)

48,008✔

2778

      ptr_reg = lower_link_var(lu, decl);   // External variable

2,824✔

2779

   else if (var & INSTANCE_BIT) {

45,184✔

2781

      vcode_var_t pkg_var = var & ~INSTANCE_BIT;

25✔

2782

      vcode_reg_t pkg_reg;

25✔

2783

      if (hops == 0)

25✔

2784

         pkg_reg = emit_load(pkg_var);

1✔

2786

         pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var));

24✔

2788

      vcode_type_t vtype = lower_var_type(decl);

25✔

2789

      ptr_reg = emit_link_var(pkg_reg, tree_ident(decl), vtype);

25✔

2791

   else if (hops > 0)

45,159✔

2792

      ptr_reg = emit_var_upref(hops, var);

4,831✔

2794

   if (ptr_reg != VCODE_INVALID_REG) {

7,680✔

2795

      if (ctx == EXPR_LVALUE)

7,680✔

2797

      else if (type_is_scalar(type))

6,985✔

2798

         return emit_load_indirect(ptr_reg);

1,538✔

2799

      else if (have_uarray_ptr(ptr_reg))

5,447✔

2800

         return emit_load_indirect(ptr_reg);

683✔

2804

   else if (type_is_array(type) && type_const_bounds(type))

40,328✔

2805

      return emit_index(var, VCODE_INVALID_REG);

8,467✔

2806

   else if (type_is_record(type) || type_is_protected(type))

31,861✔

2807

      return emit_index(var, VCODE_INVALID_REG);

2,382✔

2808

   else if ((type_is_scalar(type) || type_is_file(type) || type_is_access(type))

29,479✔

2809

            && ctx == EXPR_LVALUE)

18,801✔

2810

      return emit_index(var, VCODE_INVALID_REG);

2,943✔

2812

      return emit_load(var);

26,536✔

2815

static vcode_reg_t lower_signal_ref(lower_unit_t *lu, tree_t decl)

30,593✔

2817

   int hops = 0;

30,593✔

2818

   vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops);

30,593✔

2820

   vcode_reg_t ptr_reg;

30,593✔

2821

   if (var == VCODE_INVALID_VAR) {

30,593✔

2823

      ptr_reg = lower_link_var(lu, decl);

2,257✔

2825

   else if (var & INSTANCE_BIT) {

28,336✔

2827

      vcode_var_t pkg_var = var & ~INSTANCE_BIT;

45✔

2828

      vcode_reg_t pkg_reg;

45✔

2829

      if (hops == 0)

45✔

2832

         pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var));

45✔

2834

      vcode_type_t vtype = lower_signal_type(tree_type(decl));

45✔

2835

      ptr_reg = emit_link_var(pkg_reg, tree_ident(decl), vtype);

45✔

2837

   else if (hops == 0 && vtype_is_scalar(vcode_var_type(var)))

28,291✔

2838

      return emit_load(var);

69✔

2839

   else if (hops == 0)

28,222✔

2840

      ptr_reg = emit_index(var, VCODE_INVALID_REG);

12✔

2842

      ptr_reg = emit_var_upref(hops, var);

28,210✔

2844

   if (!vtype_is_scalar(vtype_pointed(vcode_reg_type(ptr_reg))))

30,524✔

2847

   return emit_load_indirect(ptr_reg);

27,627✔

2850

static vcode_reg_t lower_port_ref(lower_unit_t *lu, tree_t decl)

17,902✔

2852

   int hops = 0;

17,902✔

2853

   vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops);

17,902✔

2854

   if (var == VCODE_INVALID_VAR) {

17,902✔

2859

   if (hops == 0 && vtype_is_scalar(vcode_var_type(var)))

17,902✔

2860

      return emit_load(var);

674✔

2862

   vcode_reg_t ptr_reg;

17,228✔

2863

   if (hops == 0)

17,228✔

2864

      ptr_reg = emit_index(var, VCODE_INVALID_REG);

426✔

2866

      ptr_reg = emit_var_upref(hops, var);

16,802✔

2868

   if (!vtype_is_scalar(vtype_pointed(vcode_reg_type(ptr_reg))))

17,228✔

2871

   return emit_load_indirect(ptr_reg);

15,479✔

2874

static vcode_reg_t lower_param_ref(lower_unit_t *lu, tree_t decl)

37,280✔

2876

   int hops = 0;

37,280✔

2877

   int obj = lower_search_vcode_obj(decl, lu, &hops);

37,280✔

2879

   const bool is_proc_var = (obj != -1 && !!(obj & PARAM_VAR_BIT));

37,280✔

2880

   obj &= ~PARAM_VAR_BIT;

37,280✔

2882

   if (hops > 0) {

37,280✔

2884

      return emit_load_indirect(emit_var_upref(hops, obj));

77✔

2886

   else if (is_proc_var)

37,203✔

2887

      return emit_load(obj);

1,941✔

2889

      vcode_reg_t reg = obj;

35,262✔

2890

      const bool undefined_in_thunk =

70,524✔

2891

         lu->mode == LOWER_THUNK && (reg == VCODE_INVALID_REG

35,262✔

2894

      if (undefined_in_thunk) {

35,262✔

2917

static vcode_reg_t lower_generic_ref(lower_unit_t *lu, tree_t decl,

3,140✔

2920

   type_t type = tree_type(decl);

3,140✔

2922

   int hops = 0;

3,140✔

2923

   vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops);

3,140✔

2924

   vcode_reg_t ptr_reg = VCODE_INVALID_REG;

3,140✔

2926

   if (var == VCODE_INVALID_VAR) {

3,140✔

2927

      tree_t unit;

41✔

2928

      if (tree_kind((unit = tree_container(decl))) == T_PACK_INST) {

41✔

2929

         vcode_reg_t context = emit_link_package(tree_ident(unit));

26✔

2930

         ptr_reg = emit_link_var(context, tree_ident(decl), lower_type(type));

26✔

2932

      else if (lu->mode == LOWER_THUNK) {

15✔

2933

         type_t type = tree_type(decl);

15✔

2934

         emit_comment("Cannot resolve generic %s", istr(tree_ident(decl)));

15✔

2935

         return emit_undefined(lower_type(type), lower_bounds(type));

15✔

2943

   else if (var & INSTANCE_BIT) {

3,099✔

2945

      vcode_var_t pkg_var = var & ~INSTANCE_BIT;

13✔

2946

      vcode_reg_t pkg_reg;

13✔

2947

      if (hops == 0)

13✔

2948

         pkg_reg = emit_load(pkg_var);

1✔

2950

         pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var));

12✔

2952

      vcode_type_t vtype = lower_var_type(decl);

13✔

2953

      ptr_reg = emit_link_var(pkg_reg, tree_ident(decl), vtype);

13✔

2955

   else if (hops > 0)

3,086✔

2956

      ptr_reg = emit_var_upref(hops, var);

1,505✔

2958

   if (ptr_reg != VCODE_INVALID_REG) {

1,544✔

2959

      if (type_is_scalar(type))

1,544✔

2960

         return emit_load_indirect(ptr_reg);

1,085✔

2961

      else if (type_is_array(type) && !type_const_bounds(type))

459✔

2962

         return emit_load_indirect(ptr_reg);

208✔

2964

         return ptr_reg;

251✔

2966

   else if (type_is_array(type) && type_const_bounds(type))

1,581✔

2967

      return emit_index(var, VCODE_INVALID_REG);

7✔

2968

   else if (type_is_record(type) || type_is_protected(type))

1,574✔

2969

      return emit_index(var, VCODE_INVALID_REG);

98✔

2971

      return emit_load(var);

1,476✔

2974

static vcode_reg_t lower_alias_ref(lower_unit_t *lu, tree_t alias,

1,751✔

2977

   tree_t value = tree_value(alias);

1,751✔

2978

   type_t type = tree_type(tree_has_type(alias) ? alias : value);

1,999✔

2980

   if (tree_kind(value) == T_EXTERNAL_NAME) {

1,751✔

2982

      int hops = 0;

90✔

2983

      vcode_var_t var = lower_search_vcode_obj(value, lu, &hops);

90✔

2984

      assert(var != VCODE_INVALID_VAR);

90✔

2986

      vcode_reg_t ptr_reg;

90✔

2987

      if (hops == 0)

90✔

2988

         ptr_reg = emit_index(var, VCODE_INVALID_REG);

87✔

2990

         ptr_reg = emit_var_upref(hops, var);

3✔

2992

      vcode_reg_t result_reg = emit_load_indirect(ptr_reg);

90✔

2993

      if (type_is_record(type))

90✔

2996

         return emit_load_indirect(result_reg);

69✔

2998

   else if (!type_is_array(type))

1,661✔

2999

      return lower_expr(lu, value, ctx);

157✔

3001

   int hops = 0;

1,504✔

3002

   vcode_var_t var = lower_get_var(lu, alias, &hops);

1,504✔

3003

   if (var == VCODE_INVALID_VAR) {

1,504✔

3004

      if (lu->mode == LOWER_THUNK)

10✔

3008

         return lower_link_var(lu, alias);

10✔

3011

   else if (var & INSTANCE_BIT) {

1,494✔

3013

      vcode_var_t pkg_var = var & ~INSTANCE_BIT;

6✔

3014

      vcode_reg_t pkg_reg;

6✔

3015

      if (hops == 0)

6✔

3018

         pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var));

6✔

3020

      vcode_type_t vtype = lower_alias_type(alias);

6✔

3021

      return emit_link_var(pkg_reg, tree_ident(alias), vtype);

6✔

3024

   if (hops == 0)

1,488✔

3025

      return emit_load(var);

1,272✔

3027

      return emit_load_indirect(emit_var_upref(hops, var));

216✔

3030

static bool lower_is_trivial_constant(tree_t decl)

15,603✔

3032

   if (!type_is_scalar(tree_type(decl)))

15,603✔

3034

   else if (!tree_has_value(decl))

7,473✔

3037

      return tree_kind(tree_value(decl)) == T_LITERAL;

6,910✔

3040

static vcode_reg_t lower_ref(lower_unit_t *lu, tree_t ref, expr_ctx_t ctx)

204,054✔

3042

   tree_t decl = tree_ref(ref);

204,054✔

3044

   tree_kind_t kind = tree_kind(decl);

204,054✔

3045

   switch (kind) {

204,054✔

3046

   case T_ENUM_LIT:

65,672✔

3047

      if (ctx == EXPR_LVALUE)

65,672✔

3050

         return emit_const(lower_type(tree_type(decl)), tree_pos(decl));

65,672✔

3052

   case T_VAR_DECL:

32,385✔

3054

      return lower_var_ref(lu, decl, ctx);

32,385✔

3056

   case T_PORT_DECL:

17,798✔

3057

      return lower_port_ref(lu, decl);

17,798✔

3059

   case T_PARAM_DECL:

37,208✔

3060

      return lower_param_ref(lu, decl);

37,208✔

3062

   case T_GENERIC_DECL:

3,140✔

3063

      return lower_generic_ref(lu, decl, ctx);

3,140✔

3065

   case T_SIGNAL_DECL:

30,425✔

3067

      return lower_signal_ref(lu, decl);

30,425✔

3072

   case T_CONST_DECL:

15,603✔

3073

      if (ctx == EXPR_LVALUE)

15,603✔

3075

      else if (lower_is_trivial_constant(decl))

15,603✔

3078

         return lower_var_ref(lu, decl, ctx);

15,603✔

3083

   case T_ALIAS:

1,751✔

3084

      return lower_alias_ref(lu, decl, ctx);

1,751✔

3086

   case T_FUNC_BODY:

72✔

3088

      assert(standard() >= STD_19);

72✔

3089

      assert(tree_flags(decl) & TREE_F_KNOWS_SUBTYPE);

72✔

3090

      return lower_param_ref(lu, decl);

72✔

3098

static vcode_reg_t lower_external_name(lower_unit_t *lu, tree_t ref)

200✔

3100

   type_t type = tree_type(ref), base = type_base_recur(type);

200✔

3102

   vcode_type_t vtype, vbounds = lower_bounds(type);

200✔

3103

   if (tree_class(ref) == C_SIGNAL)

200✔

3104

      vtype = lower_signal_type(base);

168✔

3106

      vtype = lower_type(base);

32✔

3108

   ident_t scope;

200✔

3109

   for (vcode_unit_t vu = lu->vunit;; vu = vcode_unit_context(vu)) {

398✔

3110

      scope = vcode_unit_name(vu);

398✔

3112

      const vunit_kind_t kind = vcode_unit_kind(vu);

398✔

3113

      if (kind == VCODE_UNIT_PACKAGE || kind == VCODE_UNIT_INSTANCE)

398✔

3117

   int hops = 0;

200✔

3118

   vcode_var_t var = lower_search_vcode_obj(ref, lu, &hops);

200✔

3119

   assert(var != VCODE_INVALID_VAR);

200✔

3121

   vcode_reg_t ptr_reg;

200✔

3122

   if (hops == 0)

200✔

3123

      ptr_reg = emit_index(var, VCODE_INVALID_REG);

194✔

3125

      ptr_reg = emit_var_upref(hops, var);

6✔

3127

   vcode_reg_t cache_reg = emit_load_indirect(ptr_reg);

200✔

3128

   vcode_reg_t null_reg = emit_null(vcode_reg_type(cache_reg));

200✔

3129

   vcode_reg_t test_reg = emit_cmp(VCODE_CMP_EQ, cache_reg, null_reg);

200✔

3131

   vcode_block_t bind_bb = emit_block();

200✔

3132

   vcode_block_t cached_bb = emit_block();

200✔

3133

   emit_cond(test_reg, bind_bb, cached_bb);

200✔

3135

   vcode_select_block(bind_bb);

200✔

3137

   vcode_reg_t locus = lower_debug_locus(ref);

200✔

3138

   vcode_reg_t ext_reg = emit_bind_external(locus, scope, vtype, vbounds);

200✔

3142

   if (type_is_array(type) && !type_is_unconstrained(type)) {

200✔

3143

      vcode_reg_t array_reg = emit_load_indirect(ext_reg);

12✔

3144

      lower_check_array_sizes(lu, type, base, VCODE_INVALID_REG,

12✔

3148

   emit_store_indirect(ext_reg, ptr_reg);

200✔

3149

   emit_jump(cached_bb);

200✔

3151

   vcode_select_block(cached_bb);

200✔

3153

   vcode_reg_t result_reg = emit_load_indirect(ptr_reg);

200✔

3154

   if (type_is_record(type))

200✔

3157

      return emit_load_indirect(result_reg);

196✔

3160

static void lower_external_name_cache(tree_t t, void *ctx)

172✔

3162

   ident_t suffix = tree_ident(tree_part(t, tree_parts(t) - 1));

172✔

3163

   ident_t name = ident_prefix(suffix, ident_uniq("ename"), '.');

172✔

3165

   type_t type = tree_type(t), base = type_base_recur(type);

172✔

3166

   vcode_type_t vtype, vbounds = lower_bounds(type);

172✔

3167

   if (tree_class(t) == C_SIGNAL)

172✔

3168

      vtype = vtype_pointer(lower_signal_type(base));

140✔

3170

      vtype = vtype_pointer(lower_type(base));

32✔

3172

   vcode_var_t var = emit_var(vtype, vbounds, name, 0);

172✔

3173

   lower_put_vcode_obj(t, var, ctx);

172✔

3175

   emit_store(emit_null(vtype), var);

172✔

3176

172✔

3178

static vcode_reg_t lower_resolved(lower_unit_t *lu, type_t type,

23,803✔

3181

   if (!lower_have_signal(reg))

23,803✔

3183

   else if (have_uarray_ptr(reg))

14,146✔

3184

      reg = emit_load_indirect(reg);

3✔

3186

   if (type_is_homogeneous(type)) {

14,146✔

3187

      vcode_reg_t data_reg, count_reg = VCODE_INVALID_REG;

13,118✔

3188

      if (vcode_reg_kind(reg) == VCODE_TYPE_POINTER)

13,118✔

3189

         data_reg = emit_resolved(emit_load_indirect(reg), count_reg);

932✔

3191

         data_reg = emit_resolved(lower_array_data(reg), count_reg);

12,186✔

3193

      if (vcode_reg_kind(reg) == VCODE_TYPE_UARRAY)

13,118✔

3194

         return lower_rewrap(data_reg, reg);

311✔

3202

      ident_t base_id = type_ident(type_base_recur(type));

1,028✔

3203

      ident_t helper_func = ident_prefix(base_id, ident_new("resolved"), '$');

1,028✔

3205

      vcode_reg_t arg_reg = reg;

1,028✔

3206

      if (type_is_array(type)) {

1,028✔

3207

         if (have_uarray_ptr(arg_reg))

308✔

3209

         else if (vcode_reg_kind(arg_reg) != VCODE_TYPE_UARRAY)

308✔

3210

            arg_reg = lower_wrap(lu, type, reg);

110✔

3213

      vcode_type_t vrtype = lower_func_result_type(type);

1,028✔

3215

      vcode_reg_t args[] = { lower_context_for_call(lu, helper_func), arg_reg };

1,028✔

3216

      return emit_fcall(helper_func, vrtype, vrtype, args, 2);

1,028✔

3220

static vcode_reg_t lower_array_off(lower_unit_t *lu, vcode_reg_t off,

22,748✔

3226

   assert(vtype_kind(vcode_reg_type(off)) == VCODE_TYPE_INT);

22,748✔

3228

   vcode_reg_t zeroed = VCODE_INVALID_REG;

22,748✔

3229

   if (have_array_metadata(type, array)) {

22,748✔

3230

      vcode_reg_t left_reg = lower_array_left(lu, type, dim, array);

8,862✔

3232

      vcode_reg_t downto = emit_sub(left_reg, off);

8,862✔

3233

      vcode_reg_t upto   = emit_sub(off, left_reg);

8,862✔

3234

      zeroed = emit_select(emit_uarray_dir(array, dim), downto, upto);

8,862✔

3237

      tree_t r = range_of(type, dim);

13,886✔

3238

      vcode_reg_t left = lower_range_left(lu, r);

13,886✔

3239

      switch (tree_subkind(r)) {

13,886✔

3240

      case RANGE_TO:

10,523✔

3241

         zeroed = emit_sub(off, left);

10,523✔

3242

         break;

10,523✔

3243

      case RANGE_DOWNTO:

3,363✔

3244

         zeroed = emit_sub(left, off);

3,363✔

3245

         break;

3,363✔

3257

   return emit_cast(vtype_offset(), VCODE_INVALID_TYPE, zeroed);

22,748✔

3260

static vcode_reg_t lower_array_ref(lower_unit_t *lu, tree_t ref, expr_ctx_t ctx)

18,152✔

3262

   tree_t value = tree_value(ref);

18,152✔

3264

   vcode_reg_t array = lower_expr(lu, value, ctx);

18,152✔

3265

   if (array == VCODE_INVALID_REG)

18,152✔

3268

   if (have_uarray_ptr(array))

18,152✔

3269

      array = emit_load_indirect(array);

9✔

3271

   DEBUG_ONLY({

18,152✔

3275

});

18,152✔

3277

   type_t value_type = tree_type(value);

18,152✔

3279

   const bool elide_bounds = tree_flags(ref) & TREE_F_ELIDE_BOUNDS;

18,152✔

3281

   vcode_reg_t offset_reg = emit_const(vtype_offset(), 0);

18,152✔

3282

   const int nparams = tree_params(ref);

18,152✔

3283

   for (int i = 0; i < nparams; i++) {

37,872✔

3284

      tree_t p = tree_param(ref, i);

19,720✔

3285

      assert(tree_subkind(p) == P_POS);

19,720✔

3287

      tree_t index = tree_value(p);

19,720✔

3288

      vcode_reg_t index_reg = lower_rvalue(lu, index);

19,720✔

3290

      if (!elide_bounds) {

19,720✔

3291

         vcode_reg_t left_reg  = lower_array_left(lu, value_type, i, array);

12,858✔

3292

         vcode_reg_t right_reg = lower_array_right(lu, value_type, i, array);

12,858✔

3293

         vcode_reg_t dir_reg   = lower_array_dir(lu, value_type, i, array);

12,858✔

3295

         vcode_reg_t locus = lower_debug_locus(index);

12,858✔

3296

         emit_index_check(index_reg, left_reg, right_reg, dir_reg,

12,858✔

3300

      if (i > 0) {

19,720✔

3301

         vcode_reg_t stride = lower_array_len(lu, value_type, i, array);

1,568✔

3302

         offset_reg = emit_mul(offset_reg, stride);

1,568✔

3305

      vcode_reg_t zerored_reg =

19,720✔

3306

         lower_array_off(lu, index_reg, array, value_type, i);

19,720✔

3307

      offset_reg = emit_add(offset_reg, zerored_reg);

19,720✔

3310

   vcode_reg_t stride_reg = lower_array_stride(lu, value_type, array);

18,152✔

3311

   offset_reg = emit_mul(offset_reg, stride_reg);

18,152✔

3313

   vcode_reg_t data_reg = lower_array_data(array);

18,152✔

3314

   vcode_reg_t ptr_reg = emit_array_ref(data_reg, offset_reg);

18,152✔

3316

   type_t elem_type = type_elem(value_type);

18,152✔

3317

   if (type_is_array(elem_type) && !type_const_bounds(elem_type))

18,152✔

3318

      return lower_wrap_element(lu, value_type, array, ptr_reg);

252✔

3320

      return ptr_reg;

17,900✔

3323

static vcode_reg_t lower_array_slice(lower_unit_t *lu, tree_t slice,

2,641✔

3326

   tree_t value = tree_value(slice);

2,641✔

3327

   tree_t r     = tree_range(slice, 0);

2,641✔

3328

   type_t type  = tree_type(value);

2,641✔

3330

   vcode_reg_t left_reg  = lower_range_left(lu, r);

2,641✔

3331

   vcode_reg_t right_reg = lower_range_right(lu, r);

2,641✔

3332

   vcode_reg_t kind_reg  = lower_range_dir(lu, r);

2,641✔

3333

   vcode_reg_t null_reg  = emit_range_null(left_reg, right_reg, kind_reg);

2,641✔

3334

   vcode_reg_t array_reg = lower_expr(lu, value, ctx);

2,641✔

3336

   int64_t null_const;

2,641✔

3337

   const bool known_not_null =

5,282✔

3338

      vcode_reg_const(null_reg, &null_const) && null_const == 0;

2,641✔

3340

   vcode_block_t after_bounds_bb = VCODE_INVALID_BLOCK;

2,641✔

3341

   if (!known_not_null) {

2,641✔

3342

      vcode_block_t not_null_bb = emit_block();

1,476✔

3343

      after_bounds_bb = emit_block();

1,476✔

3344

      emit_cond(null_reg, after_bounds_bb, not_null_bb);

1,476✔

3346

      vcode_select_block(not_null_bb);

1,476✔

3349

   vcode_reg_t aleft_reg  = lower_array_left(lu, type, 0, array_reg);

2,641✔

3350

   vcode_reg_t aright_reg = lower_array_right(lu, type, 0, array_reg);

2,641✔

3351

   vcode_reg_t adir_reg   = lower_array_dir(lu, type, 0, array_reg);

2,641✔

3353

   vcode_reg_t locus = lower_debug_locus(r);

2,641✔

3354

   emit_index_check(left_reg, aleft_reg, aright_reg, adir_reg,

2,641✔

3356

   emit_index_check(right_reg, aleft_reg, aright_reg, adir_reg,

2,641✔

3359

   if (!known_not_null) {

2,641✔

3360

      emit_jump(after_bounds_bb);

1,476✔

3361

      vcode_select_block(after_bounds_bb);

1,476✔

3364

   if (array_reg == VCODE_INVALID_REG)

2,641✔

3367

   vcode_reg_t stride_reg = lower_array_stride(lu, type, array_reg);

2,641✔

3369

   vcode_reg_t data_reg = lower_array_data(array_reg);

2,641✔

3370

   vcode_reg_t off_reg = lower_array_off(lu, left_reg, array_reg, type, 0);

2,641✔

3371

   vcode_reg_t ptr_reg =

2,641✔

3372

      emit_array_ref(data_reg, emit_mul(off_reg, stride_reg));

2,641✔

3374

   if (type_const_bounds(type))

2,641✔

3377

   vcode_dim_t dim0 = {

1,480✔

3383

   const int ndims = dims_for_type(type);

1,480✔

3384

   if (ndims > 1) {

1,480✔

3385

      assert(vcode_reg_kind(array_reg) == VCODE_TYPE_UARRAY);

3✔

3387

      vcode_dim_t *dims LOCAL = xmalloc_array(ndims, sizeof(vcode_dim_t));

6✔

3388

      dims[0] = dim0;

3✔

3389

      for (int i = 1; i < ndims; i++) {

6✔

3390

         dims[i].left  = emit_uarray_left(array_reg, i);

3✔

3391

         dims[i].right = emit_uarray_right(array_reg, i);

3✔

3392

         dims[i].dir   = emit_uarray_dir(array_reg, i);

3✔

3395

      return emit_wrap(ptr_reg, dims, ndims);

3✔

3398

      return emit_wrap(ptr_reg, &dim0, 1);

1,477✔

3401

static inline void lower_copy_vals(vcode_reg_t *restrict dst,

186,096✔

3404

   assert(n >= 0);

186,096✔

3405

   memcpy(dst, src, n * sizeof(vcode_reg_t));

186,096✔

3406

186,096✔

3408

static vcode_reg_t *lower_const_array_aggregate(lower_unit_t *lu, tree_t t,

6,483✔

3412

   if ((*n_elems = lower_array_const_size(type)) == 0)

6,483✔

3415

   vcode_reg_t *vals = xmalloc_array(*n_elems, sizeof(vcode_reg_t));

6,363✔

3417

   for (int i = 0; i < *n_elems; i++)

1,696,744✔

3418

      vals[i] = VCODE_INVALID_REG;

1,690,381✔

3420

   tree_t r = range_of(type, dim);

6,363✔

3421

   const int64_t left = assume_int(tree_left(r));

6,363✔

3422

   const bool is_downto = (tree_subkind(r) == RANGE_DOWNTO);

6,363✔

3424

   int pos = 0;

6,363✔

3425

   const int nassocs = tree_assocs(t);

6,363✔

3426

   for (int i = 0; i < nassocs; i++) {

58,669✔

3427

      tree_t a = tree_assoc(t, i);

52,306✔

3428

      tree_t value = tree_value(a);

52,306✔

3429

      type_t value_type = tree_type(value);

52,306✔

3431

      const tree_kind_t value_kind = tree_kind(value);

52,306✔

3433

      vcode_reg_t tmp = VCODE_INVALID_REG;

52,306✔

3434

      vcode_reg_t *sub = &tmp;

52,306✔

3435

      int nsub = 1;

52,306✔

3436

      if (value_kind == T_AGGREGATE) {

52,306✔

3437

         if (type_is_array(value_type))

3,703✔

3438

            sub = lower_const_array_aggregate(lu, value, value_type, 0, &nsub);

3,296✔

3439

         else if (type_is_record(value_type))

407✔

3440

            *sub = lower_record_aggregate(lu, value, true,

407✔

3441

                                          lower_is_const(value),

407✔

3446

      else if (value_kind == T_STRING)

48,603✔

3447

         sub = lower_string_literal_chars(value, &nsub);

382✔

3449

         *sub = lower_rvalue(lu, value);

48,221✔

3451

      switch (tree_subkind(a)) {

52,306✔

3452

      case A_POS:

49,757✔

3454

         lower_copy_vals(vals + pos, sub, nsub);

49,757✔

3455

         pos += nsub;

49,757✔

3456

         break;

49,757✔

3458

      case A_NAMED:

1,850✔

3460

            const int64_t name = assume_int(tree_name(a));

1,850✔

3461

            const int64_t off  = is_downto ? left - name : name - left;

1,850✔

3462

            lower_copy_vals(vals + (off * nsub), sub, nsub);

1,850✔

3464

         break;

1,850✔

3466

      case A_OTHERS:

409✔

3467

         assert((*n_elems % nsub) == 0);

409✔

3468

         for (int j = 0; j < (*n_elems / nsub); j++) {

129,154✔

3469

            if (vals[j * nsub] == VCODE_INVALID_REG)

128,745✔

3470

               lower_copy_vals(vals + (j * nsub), sub, nsub);

127,332✔

3474

      case A_RANGE:

284✔

3476

            tree_t r = tree_range(a, 0);

284✔

3478

            int64_t r_low, r_high;

284✔

3479

            range_bounds(r, &r_low, &r_high);

284✔

3481

            for (int j = r_low; j <= r_high; j++) {

7,435✔

3482

               const int64_t off = is_downto ? left - j : j - left;

7,151✔

3483

               lower_copy_vals(vals + (off * nsub), sub, nsub);

7,151✔

3486

         break;

284✔

3488

      case A_SLICE:

6✔

3490

            assert(standard() >= STD_08);

6✔

3492

            tree_t r = tree_range(a, 0);

6✔

3493

            const int64_t r_left = assume_int(tree_left(r));

6✔

3494

            const int64_t off = is_downto ? left - r_left : r_left - left;

6✔

3496

            lower_copy_vals(vals + off, sub, nsub);

6✔

3498

         break;

6✔

3501

      if (sub != &tmp)

52,306✔

3502

         free(sub);

3,678✔

3506

   for (int i = 0; i < *n_elems; i++) {

1,696,744✔

3507

      if (vals[i] == VCODE_INVALID_REG) {

1,690,381✔

3517

static vcode_reg_t lower_record_sub_aggregate(lower_unit_t *lu, tree_t value,

6,722✔

3520

   type_t ftype = tree_type(field);

6,722✔

3522

   if (is_const && type_is_array(ftype)) {

6,722✔

3523

      if (tree_kind(value) == T_STRING)

407✔

3524

         return lower_string_literal(value, true);

312✔

3525

      else if (lu->mode == LOWER_THUNK && !type_const_bounds(ftype))

95✔

3528

         int nvals;

95✔

3529

         vcode_reg_t *values LOCAL =

190✔

3530

            lower_const_array_aggregate(lu, value, ftype, 0, &nvals);

95✔

3531

         return emit_const_array(lower_type(ftype), values, nvals);

95✔

3534

   else if (is_const && type_is_record(ftype))

6,315✔

3535

      return lower_record_aggregate(lu, value, true, true, VCODE_INVALID_REG);

90✔

3536

   else if (type_is_scalar(ftype) || type_is_access(ftype))

6,225✔

3537

      return lower_rvalue(lu, value);

5,287✔

3538

   else if (type_is_array(ftype)) {

938✔

3539

      vcode_reg_t value_reg = lower_rvalue(lu, value);

829✔

3540

      if (!type_is_unconstrained(ftype)) {

829✔

3541

         vcode_reg_t locus = lower_debug_locus(field);

631✔

3542

         lower_check_array_sizes(lu, ftype, tree_type(value),

631✔

3545

      return lower_coerce_arrays(lu, tree_type(value), ftype, value_reg);

829✔

3548

      return lower_rvalue(lu, value);

109✔

3551

static vcode_reg_t lower_record_aggregate(lower_unit_t *lu, tree_t expr,

2,799✔

3555

   type_t type = tree_type(expr);

2,799✔

3556

   const int nfields = type_fields(type);

2,799✔

3557

   const int nassocs = tree_assocs(expr);

2,799✔

3559

   vcode_reg_t *vals LOCAL = xcalloc_array(nfields, sizeof(vcode_reg_t));

5,598✔

3560

   for (int i = 0; i < nfields; i++)

9,521✔

3561

      vals[i] = VCODE_INVALID_REG;

6,722✔

3563

   tree_t *map LOCAL = xcalloc_array(nfields, sizeof(tree_t));

5,598✔

3565

   for (int i = 0; i < nassocs; i++) {

9,376✔

3566

      tree_t a = tree_assoc(expr, i);

6,577✔

3567

      tree_t value = tree_value(a);

6,577✔

3569

      switch (tree_subkind(a)) {

6,577✔

3570

      case A_POS:

5,599✔

3572

            const int pos = tree_pos(a);

5,599✔

3573

            tree_t field = type_field(type, pos);

5,599✔

3574

            vals[pos] = lower_record_sub_aggregate(lu, value, field, is_const);

5,599✔

3575

            map[pos] = value;

5,599✔

3577

         break;

5,599✔

3579

      case A_NAMED:

896✔

3581

            const int pos = tree_pos(tree_ref(tree_name(a)));

896✔

3582

            tree_t field = type_field(type, pos);

896✔

3583

            vals[pos] = lower_record_sub_aggregate(lu, value, field, is_const);

896✔

3584

            map[pos] = value;

896✔

3586

         break;

896✔

3589

         for (int j = 0; j < nfields; j++) {

334✔

3590

            if (vals[j] == VCODE_INVALID_REG) {

252✔

3591

               tree_t field = type_field(type, j);

227✔

3592

               vals[j] = lower_record_sub_aggregate(lu, value, field, is_const);

227✔

3593

               map[j] = value;

227✔

3603

   for (int i = 0; i < nfields; i++)

9,521✔

3604

      assert(vals[i] != VCODE_INVALID_REG);

6,722✔

3606

   if (is_const) {

2,799✔

3607

      vcode_reg_t reg = emit_const_record(lower_type(type), vals, nfields);

2,140✔

3608

      return nest ? reg : emit_address_of(reg);

2,140✔

3611

      vcode_type_t vtype = lower_type(type);

659✔

3612

      vcode_reg_t mem_reg = hint;

659✔

3613

      if (mem_reg == VCODE_INVALID_REG) {

659✔

3614

         vcode_var_t tmp_var = lower_temp_var(lu, "record", vtype, vtype);

420✔

3615

         mem_reg = emit_index(tmp_var, VCODE_INVALID_REG);

420✔

3618

      for (int i = 0; i < nfields; i++) {

2,307✔

3619

         tree_t f = type_field(type, i), cons;

1,648✔

3620

         type_t ftype = tree_type(f);

1,648✔

3621

         vcode_reg_t ptr_reg = emit_record_ref(mem_reg, i);

1,648✔

3622

         if (type_is_array(ftype)) {

1,648✔

3623

            if (have_uarray_ptr(ptr_reg)) {

829✔

3624

               type_t value_type = tree_type(map[i]);

238✔

3625

               vcode_reg_t wrap_reg =

238✔

3626

                  lower_wrap_with_new_bounds(lu, value_type, ftype,

476✔

3627

                                             vals[i], vals[i]);

238✔

3629

               if ((cons = type_constraint_for_field(type, f))) {

238✔

3631

                  type_t ctype = tree_type(cons);

74✔

3632

                  if (!type_is_unconstrained(ctype)) {

74✔

3633

                     vcode_reg_t locus = lower_debug_locus(map[i]);

74✔

3634

                     lower_check_array_sizes(lu, ctype, value_type,

74✔

3640

               emit_store_indirect(wrap_reg, ptr_reg);

238✔

3643

               vcode_reg_t src_reg = lower_array_data(vals[i]);

591✔

3644

               vcode_reg_t length_reg =

591✔

3645

                  lower_array_total_len(lu, ftype, vals[i]);

591✔

3646

               emit_copy(ptr_reg, src_reg, length_reg);

591✔

3649

         else if (type_is_record(ftype))

819✔

3650

            emit_copy(ptr_reg, vals[i], VCODE_INVALID_REG);

109✔

3652

            emit_store_indirect(vals[i], ptr_reg);

710✔

3659

static bool lower_can_use_const_rep(tree_t expr, int *length, tree_t *elem)

3,969✔

3661

   switch (tree_kind(expr)) {

3,969✔

3662

   case T_AGGREGATE:

3,957✔

3664

         type_t type = tree_type(expr);

3,957✔

3665

         assert(type_const_bounds(type));

3,957✔

3667

         tree_t a0 = tree_assoc(expr, 0);

3,957✔

3668

         if (tree_subkind(a0) != A_OTHERS)

3,957✔

3671

         tree_t others = tree_value(a0);

1,007✔

3672

         type_t elem_type = tree_type(others);

1,007✔

3674

         if (type_is_array(elem_type)) {

1,007✔

3675

            if (!lower_can_use_const_rep(others, length, elem))

184✔

3678

         else if (type_is_scalar(elem_type))

823✔

3679

            *elem = others;

808✔

3683

         *length = lower_array_const_size(type);

969✔

3684

         return true;

969✔

3687

   case T_STRING:

12✔

3689

         const int nchars = tree_chars(expr);

12✔

3690

         if (nchars == 0)

12✔

3693

         tree_t c0 = tree_char(expr, 0);

11✔

3694

         tree_t d0 = tree_ref(c0);

11✔

3696

         for (int i = 1; i < nchars; i++) {

45✔

3697

            if (tree_ref(tree_char(expr, i)) != d0)

41✔

3701

         *elem = c0;

4✔

3702

         *length = nchars;

4✔

3703

         return true;

4✔

3711

static vcode_reg_t lower_aggregate_bounds(lower_unit_t *lu, tree_t expr,

227✔

3717

   type_t type = tree_type(expr);

227✔

3718

   assert(type_is_unconstrained(type));

227✔

3720

   type_t index_type = index_type_of(type, 0);

227✔

3722

   vcode_reg_t left_reg = VCODE_INVALID_REG,

227✔

3723

      right_reg = VCODE_INVALID_REG,

227✔

3724

      dir_reg = VCODE_INVALID_REG;

227✔

3726

   range_kind_t dir;

227✔

3727

   int64_t ileft, iright;

227✔

3728

   if (calculate_aggregate_bounds(expr, &dir, &ileft, &iright)) {

227✔

3729

      vcode_type_t vindex = lower_type(index_type);

18✔

3730

      left_reg = emit_const(vindex, ileft);

18✔

3731

      right_reg = emit_const(vindex, iright);

18✔

3732

      dir_reg = emit_const(vtype_bool(), dir);

18✔

3735

      vcode_type_t voffset = vtype_offset();

209✔

3736

      vcode_reg_t length_reg = VCODE_INVALID_REG;

209✔

3738

      const int nassocs = tree_assocs(expr);

209✔

3739

      for (int i = 0; i < nassocs; i++) {

428✔

3740

         tree_t a = tree_assoc(expr, i);

219✔

3741

         const assoc_kind_t akind = tree_subkind(a);

219✔

3743

         switch (akind) {

219✔

3744

         case A_NAMED:

3✔

3745

            assert(nassocs == 1);    // Must have a single association

3✔

3746

            left_reg = right_reg = lower_rvalue(lu, tree_name(a));

3✔

3747

            dir_reg = lower_range_dir(lu, range_of(index_type, 0));

3✔

3748

            break;

3✔

3749

         case A_RANGE:

196✔

3752

               tree_t r = tree_range(a, 0);

196✔

3753

               left_reg = lower_range_left(lu, r);

196✔

3754

               right_reg = lower_range_right(lu, r);

196✔

3755

               dir_reg = lower_range_dir(lu, r);

196✔

3757

            break;

196✔

3758

         case A_POS:

20✔

3761

               vcode_reg_t count_reg;

20✔

3762

               if (akind == A_CONCAT) {

20✔

3763

                  type_t value_type = tree_type(tree_value(a));

19✔

3764

                  count_reg = lower_array_len(lu, value_type, 0, value_regs[i]);

19✔

3767

                  count_reg = emit_const(voffset, 1);

1✔

3769

               if (length_reg == VCODE_INVALID_REG)

20✔

3772

                  length_reg = emit_add(length_reg, count_reg);

10✔

3781

      if (length_reg != VCODE_INVALID_REG) {

209✔

3782

         vcode_type_t vindex = lower_type(index_type);

10✔

3783

         vcode_reg_t delta_reg = emit_sub(length_reg, emit_const(voffset, 1));

10✔

3784

         vcode_reg_t cast_reg = emit_cast(vindex, vindex, delta_reg);

10✔

3786

         vcode_reg_t index_right_reg;

10✔

3787

         lower_get_scalar_type_bounds(lu, index_type, &left_reg,

10✔

3790

         right_reg = emit_add(left_reg, cast_reg);

10✔

3794

   vcode_reg_t null_reg = emit_null(vtype_pointer(vtype_offset()));

227✔

3796

   const int ndims = dims_for_type(type);

227✔

3797

   if (ndims > 1) {

227✔

3798

      vcode_dim_t *dims LOCAL = xmalloc_array(ndims, sizeof(vcode_dim_t));

22✔

3800

      dims[0].left  = left_reg;

11✔

3801

      dims[0].right = right_reg;

11✔

3802

      dims[0].dir   = dir_reg;

11✔

3804

      tree_t a0 = tree_value(tree_assoc(expr, 0));

11✔

3805

      vcode_reg_t a0_reg = value_regs[0];

11✔

3806

      assert(a0_reg != VCODE_INVALID_REG);

11✔

3808

      if (vcode_reg_kind(a0_reg) == VCODE_TYPE_UARRAY) {

11✔

3809

         for (int i = 1; i < ndims; i++) {

23✔

3810

            dims[i].left  = emit_uarray_left(a0_reg, i - 1);

12✔

3811

            dims[i].right = emit_uarray_right(a0_reg, i - 1);

12✔

3812

            dims[i].dir   = emit_uarray_dir(a0_reg, i - 1);

12✔

3824

      return emit_wrap(null_reg, dims, ndims);

11✔

3827

      vcode_dim_t dims[] = {

216✔

3830

      return emit_wrap(null_reg, dims, 1);

216✔

3834

static vcode_reg_t lower_array_aggregate(lower_unit_t *lu, tree_t expr,

5,551✔

3837

   emit_debug_info(tree_loc(expr));

5,551✔

3839

   type_t type = tree_type(expr);

5,551✔

3840

   type_t elem_type = type_elem(type);

5,551✔

3841

   type_t scalar_elem_type = type_elem_recur(type);

5,551✔

3843

   if (type_const_bounds(type) && lower_is_const(expr)) {

5,551✔

3844

      int rep_size = -1;

3,785✔

3845

      tree_t rep_elem = NULL;

3,785✔

3846

      if (lower_can_use_const_rep(expr, &rep_size, &rep_elem) && rep_size > 1) {

3,785✔

3847

         vcode_reg_t elem_reg = lower_rvalue(lu, rep_elem);

693✔

3848

         if (hint != VCODE_INVALID_REG) {

693✔

3849

            emit_memset(hint, elem_reg, emit_const(vtype_offset(), rep_size));

563✔

3850

            return hint;

563✔

3853

            vcode_type_t vtype = lower_type(type);

130✔

3854

            vcode_reg_t array = emit_const_rep(vtype, elem_reg, rep_size);

130✔

3855

            return emit_address_of(array);

130✔

3859

         int nvals;

3,092✔

3860

         vcode_reg_t *values LOCAL =

6,184✔

3861

            lower_const_array_aggregate(lu, expr, type, 0, &nvals);

3,092✔

3863

         vcode_reg_t array = emit_const_array(lower_type(type), values, nvals);

3,092✔

3864

         return emit_address_of(array);

3,092✔

3868

   bool all_literals = true;

1,766✔

3869

   tree_t def_value = NULL;

1,766✔

3870

   const int nassocs = tree_assocs(expr);

1,766✔

3871

   for (int i = 0; i < nassocs; i++) {

4,638✔

3872

      tree_t a = tree_assoc(expr, i);

2,872✔

3873

      switch (tree_subkind(a)) {

2,872✔

3874

      case A_POS:

1,137✔

3875

         all_literals &= (tree_kind(tree_value(a)) == T_LITERAL);

1,137✔

3876

         break;

1,137✔

3877

      case A_OTHERS:

1,299✔

3878

         def_value = tree_value(a);

1,299✔

3886

   emit_comment("Begin array aggregrate line %d", tree_loc(expr)->first_line);

1,766✔

3888

   assert(hint == VCODE_INVALID_REG || !have_uarray_ptr(hint));

1,766✔

3890

   const int ndims = dimension_of(type);

1,766✔

3891

   const bool multidim = ndims > 1;

1,766✔

3892

   const bool array_of_array = type_is_array(elem_type);

1,766✔

3893

   const bool is_unconstrained = type_is_unconstrained(type);

1,766✔

3895

   vcode_reg_t *value_regs LOCAL = xmalloc_array(nassocs, sizeof(vcode_reg_t));

3,532✔

3896

   for (int i = 0; i < nassocs; i++) {

4,638✔

3897

      tree_t a = tree_assoc(expr, i);

2,872✔

3898

      tree_t value = tree_value(a);

2,872✔

3899

      const assoc_kind_t akind = tree_subkind(a);

2,872✔

3901

      if (akind == A_CONCAT || akind == A_SLICE)

2,872✔

3902

         value_regs[i] = lower_rvalue(lu, value);   // Always need length

77✔

3903

      else if (is_unconstrained && i == 0 && (array_of_array || multidim))

2,795✔

3904

         value_regs[i] = lower_rvalue(lu, value);

11✔

3905

      else if (tree_kind(value) == T_AGGREGATE)

2,784✔

3906

         value_regs[i] = VCODE_INVALID_REG;   // Prefer to generate in-place

87✔

3908

         value_regs[i] = lower_rvalue(lu, value);

2,697✔

3911

   vcode_reg_t bounds_reg = VCODE_INVALID_REG;

1,766✔

3912

   if (is_unconstrained)

1,766✔

3913

      bounds_reg = lower_aggregate_bounds(lu, expr, value_regs);

227✔

3914

   else if (hint != VCODE_INVALID_REG

1,539✔

3915

            && vcode_reg_kind(hint) == VCODE_TYPE_UARRAY)

596✔

3917

   else if (needs_bounds_var(type))

1,310✔

3918

      bounds_reg = lower_get_type_bounds(lu, type);

859✔

3920

   vcode_reg_t dir_reg = lower_array_dir(lu, type, 0, bounds_reg);

1,766✔

3921

   vcode_reg_t left_reg = lower_array_left(lu, type, 0, bounds_reg);

1,766✔

3922

   vcode_reg_t right_reg = lower_array_right(lu, type, 0, bounds_reg);

1,766✔

3924

   vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, dir_reg);

1,766✔

3926

   vcode_type_t velem   = lower_type(scalar_elem_type);

1,766✔

3927

   vcode_type_t vbounds = lower_bounds(scalar_elem_type);

1,766✔

3928

   vcode_type_t voffset = vtype_offset();

1,766✔

3930

   if (all_literals) {

1,766✔

3933

      vcode_type_t velem = lower_type(elem_type);

4✔

3934

      vcode_type_t vbounds = lower_bounds(elem_type);

4✔

3935

      vcode_type_t vtype = vtype_carray(nassocs, velem, vbounds);

4✔

3937

      vcode_reg_t array_reg = emit_const_array(vtype, value_regs, nassocs);

4✔

3938

      vcode_reg_t mem_reg = emit_address_of(array_reg);

4✔

3940

      vcode_reg_t nassocs_reg = emit_const(voffset, nassocs);

4✔

3941

      vcode_reg_t length_reg = emit_range_length(left_reg, right_reg, dir_reg);

4✔

3943

      vcode_reg_t locus = lower_debug_locus(expr);

4✔

3944

      emit_length_check(length_reg, nassocs_reg, locus, VCODE_INVALID_REG);

4✔

3946

      vcode_dim_t dims[1] = {

4✔

3949

      return emit_wrap(mem_reg, dims, 1);

4✔

3952

   int64_t null_const;

1,762✔

3953

   bool known_not_null = false;

1,762✔

3954

   if (vcode_reg_const(null_reg, &null_const)) {

1,762✔

3955

      if (null_const) {

616✔

3956

         vcode_type_t vtype = vtype_carray(0, velem, vbounds);

1✔

3957

         vcode_reg_t mem_reg =

1✔

3958

            emit_address_of(emit_const_array(vtype, NULL, 0));

1✔

3960

         if (bounds_reg != VCODE_INVALID_REG)

1✔

3969

   vcode_reg_t stride;

1,761✔

3970

   if (array_of_array)

1,761✔

3971

      stride = lower_array_stride(lu, type, bounds_reg);

191✔

3973

      stride = emit_const(voffset, 1);

1,570✔

3975

   if (multidim) {

1,761✔

3976

      for (int i = 1; i < ndims; i++)

34✔

3977

         stride = emit_mul(stride, lower_array_len(lu, type, i, bounds_reg));

17✔

3978

      emit_comment("Multidimensional array stride is r%d", stride);

17✔

3981

   vcode_reg_t dim0_len = lower_array_len(lu, type, 0, bounds_reg);

1,761✔

3982

   vcode_reg_t len_reg = emit_mul(dim0_len, stride);

1,761✔

3984

   if (is_unconstrained)

1,761✔

3986

   else if (hint != VCODE_INVALID_REG && def_value == NULL) {

1,534✔

3990

      int64_t rlow, rhigh;

143✔

3991

      if (!folded_bounds(range_of(type, 0), &rlow, &rhigh))

143✔

3992

         hint = VCODE_INVALID_REG;

3✔

3995

   vcode_reg_t mem_reg;

1,534✔

3996

   if (hint != VCODE_INVALID_REG)

1,534✔

3997

      mem_reg = lower_array_data(hint);

588✔

3999

      mem_reg = emit_alloc(velem, vbounds, len_reg);

1,173✔

4001

   vcode_reg_t wrap_reg;

1,761✔

4002

   if (type_const_bounds(type))

1,761✔

4004

   else if (bounds_reg != VCODE_INVALID_REG)

1,311✔

4005

      wrap_reg = lower_rewrap(mem_reg, bounds_reg);

1,311✔

4026

   vcode_block_t skip_bb = VCODE_INVALID_BLOCK;

1,761✔

4027

   if (!known_not_null) {

1,761✔

4028

      vcode_block_t not_null_bb = emit_block();

1,146✔

4029

      skip_bb = emit_block();

1,146✔

4030

      emit_cond(null_reg, skip_bb, not_null_bb);

1,146✔

4032

      vcode_select_block(not_null_bb);

1,146✔

4035

   if (def_value != NULL) {

1,761✔

4037

      if (type_is_scalar(elem_type) && !multidim) {

2,066✔

4038

         vcode_reg_t def_reg = lower_rvalue(lu, def_value);

768✔

4039

         emit_memset(mem_reg, def_reg, len_reg);

768✔

4042

         vcode_block_t loop_bb = emit_block();

530✔

4043

         vcode_block_t exit_bb = emit_block();

530✔

4045

         vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

530✔

4046

         emit_store(emit_const(voffset, 0), i_var);

530✔

4050

         vcode_reg_t def_reg = VCODE_INVALID_REG;

530✔

4051

         if (type_is_scalar(elem_type) && !multidim)

530✔

4054

         emit_cond(null_reg, exit_bb, loop_bb);

530✔

4056

         vcode_select_block(loop_bb);

530✔

4058

         vcode_reg_t inc_reg = stride;

530✔

4059

         if (inc_reg == VCODE_INVALID_REG)

530✔

4062

         vcode_reg_t i_reg = emit_load(i_var);

530✔

4063

         vcode_reg_t next_reg = emit_add(i_reg, inc_reg);

530✔

4064

         emit_store(next_reg, i_var);

530✔

4066

         vcode_reg_t ptr_reg = emit_array_ref(mem_reg, i_reg);

530✔

4068

         if (def_reg == VCODE_INVALID_REG) {

530✔

4069

            if (tree_kind(def_value) == T_AGGREGATE) {

530✔

4070

               vcode_reg_t elem_reg = ptr_reg;

26✔

4071

               if (array_of_array && !multidim

26✔

4072

                   && !type_const_bounds(elem_type)) {

3✔

4073

                  assert(bounds_reg != VCODE_INVALID_REG);

3✔

4074

                  elem_reg = lower_wrap_element(lu, type, bounds_reg, ptr_reg);

3✔

4077

               def_reg = lower_aggregate(lu, def_value, elem_reg);

26✔

4080

               def_reg = lower_rvalue(lu, def_value);

504✔

4083

         if (array_of_array || multidim) {

530✔

4084

            assert(stride != VCODE_INVALID_REG);

133✔

4085

            vcode_reg_t src_reg = lower_array_data(def_reg);

133✔

4086

            emit_copy(ptr_reg, src_reg, stride);

133✔

4088

         else if (type_is_record(elem_type))

397✔

4089

            emit_copy(ptr_reg, def_reg, VCODE_INVALID_REG);

397✔

4093

         vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, len_reg);

530✔

4094

         emit_cond(done_reg, exit_bb, loop_bb);

530✔

4096

         vcode_select_block(exit_bb);

530✔

4097

         lower_release_temp(lu, i_var);

530✔

4101

   vcode_reg_t next_pos = VCODE_INVALID_REG;

1,761✔

4103

   type_t index_type = index_type_of(type, 0);

1,761✔

4104

   tree_t index_r = range_of(index_type, 0);

1,761✔

4106

   vcode_type_t vindex = lower_type(index_type);

1,761✔

4108

   vcode_reg_t low_reg = emit_select(dir_reg, right_reg, left_reg);

1,761✔

4110

   for (int i = 0; i < nassocs; i++) {

4,609✔

4111

      tree_t a = tree_assoc(expr, i);

2,848✔

4112

      tree_t value = tree_value(a);

2,848✔

4114

      const assoc_kind_t akind = tree_subkind(a);

2,848✔

4116

      vcode_reg_t count_reg = VCODE_INVALID_REG;

2,848✔

4117

      if (akind == A_CONCAT || akind == A_SLICE)

2,848✔

4118

         count_reg = lower_array_len(lu, tree_type(value), 0, value_regs[i]);

77✔

4120

      vcode_reg_t loop_bb = VCODE_INVALID_BLOCK;

2,848✔

4121

      vcode_reg_t exit_bb = VCODE_INVALID_BLOCK;

2,848✔

4123

      vcode_var_t tmp_var = VCODE_INVALID_VAR;

2,848✔

4124

      vcode_reg_t off_reg = VCODE_INVALID_REG;

2,848✔

4126

      switch (tree_subkind(a)) {

2,848✔

4127

      case A_POS:

1,114✔

4129

            if (next_pos == VCODE_INVALID_REG)

1,114✔

4130

               off_reg = emit_const(voffset, tree_pos(a));

1,104✔

4132

               off_reg = next_pos;

10✔

4133

               next_pos = emit_add(next_pos, emit_const(voffset, 1));

10✔

4136

            vcode_reg_t locus = lower_debug_locus(a);

1,114✔

4137

            vcode_reg_t hint = lower_debug_locus(index_r);

1,114✔

4139

            vcode_reg_t off_cast_reg = emit_cast(vindex, vindex, off_reg);

1,114✔

4140

            vcode_reg_t index_reg = emit_add(low_reg, off_cast_reg);

1,114✔

4142

            emit_index_check(index_reg, left_reg, right_reg,

1,114✔

4145

         break;

1,114✔

4147

      case A_CONCAT:

49✔

4149

            if (next_pos == VCODE_INVALID_REG) {

49✔

4150

               off_reg = emit_const(voffset, tree_pos(a));

28✔

4151

               next_pos = count_reg;

28✔

4154

               off_reg = next_pos;

21✔

4155

               next_pos = emit_add(next_pos, count_reg);

21✔

4158

            vcode_reg_t locus = lower_debug_locus(a);

49✔

4159

            vcode_reg_t hint = lower_debug_locus(index_r);

49✔

4161

            vcode_reg_t index_off_reg = emit_cast(vindex, vindex, off_reg);

49✔

4162

            vcode_reg_t low_index_reg = emit_add(low_reg, index_off_reg);

49✔

4164

            emit_index_check(low_index_reg, left_reg, right_reg,

49✔

4167

            vcode_reg_t one_reg = emit_const(vindex, 1);

49✔

4168

            vcode_reg_t next_index_reg =

49✔

4169

               emit_sub(emit_cast(vindex, vindex, count_reg), one_reg);

49✔

4170

            vcode_reg_t high_index_reg =

49✔

4171

               emit_add(low_index_reg, next_index_reg);

49✔

4173

            emit_index_check(high_index_reg, left_reg, right_reg,

49✔

4176

         break;

49✔

4178

      case A_NAMED:

126✔

4180

            tree_t name = tree_name(a);

126✔

4181

            vcode_reg_t name_reg = lower_rvalue(lu, name);

126✔

4182

            vcode_reg_t locus = lower_debug_locus(name);

126✔

4183

            emit_index_check(name_reg, left_reg, right_reg, dir_reg,

126✔

4185

            off_reg = lower_array_off(lu, name_reg, wrap_reg, type, 0);

126✔

4187

         break;

126✔

4189

      case A_RANGE:

233✔

4191

            loop_bb = emit_block();

233✔

4192

            exit_bb = emit_block();

233✔

4194

            tree_t r = tree_range(a, 0);

233✔

4195

            type_t rtype = tree_type(r);

233✔

4197

            vcode_reg_t r_left_reg  = lower_range_left(lu, r);

233✔

4198

            vcode_reg_t r_right_reg = lower_range_right(lu, r);

233✔

4199

            vcode_reg_t r_dir_reg   = lower_range_dir(lu, r);

233✔

4201

            vcode_reg_t locus = lower_debug_locus(r);

233✔

4202

            emit_index_check(r_left_reg, left_reg, right_reg, dir_reg,

233✔

4204

            emit_index_check(r_right_reg, left_reg, right_reg, dir_reg,

233✔

4207

            vcode_type_t vtype   = lower_type(rtype);

233✔

4208

            vcode_type_t vbounds = lower_bounds(rtype);

233✔

4210

            tmp_var = lower_temp_var(lu, "i", vtype, vbounds);

233✔

4211

            emit_store(r_left_reg, tmp_var);

233✔

4213

            vcode_reg_t null_reg =

233✔

4214

               emit_range_null(r_left_reg, r_right_reg, r_dir_reg);

233✔

4215

            emit_cond(null_reg, exit_bb, loop_bb);

233✔

4217

            vcode_select_block(loop_bb);

233✔

4218

            emit_debug_info(tree_loc(a));

233✔

4220

            vcode_reg_t i_reg = emit_load(tmp_var);

233✔

4221

            off_reg = lower_array_off(lu, i_reg, wrap_reg, type, 0);

233✔

4223

         break;

233✔

4225

      case A_SLICE:

28✔

4227

            tree_t r = tree_range(a, 0);

28✔

4229

            vcode_reg_t r_left_reg  = lower_range_left(lu, r);

28✔

4230

            vcode_reg_t r_right_reg = lower_range_right(lu, r);

28✔

4231

            vcode_reg_t r_dir_reg   = lower_range_dir(lu, r);

28✔

4233

            vcode_reg_t locus = lower_debug_locus(a);

28✔

4234

            emit_index_check(r_left_reg, left_reg, right_reg, dir_reg,

28✔

4236

            emit_index_check(r_right_reg, left_reg, right_reg, dir_reg,

28✔

4239

            vcode_reg_t expect_reg =

28✔

4240

               emit_range_length(r_left_reg, r_right_reg, r_dir_reg);

28✔

4241

            emit_length_check(expect_reg, count_reg, locus, VCODE_INVALID_REG);

28✔

4243

            vcode_reg_t dir_cmp_reg =

28✔

4244

               emit_cmp(VCODE_CMP_EQ, dir_reg, r_dir_reg);

28✔

4245

            vcode_reg_t base_reg =

28✔

4246

               emit_select(dir_cmp_reg, r_left_reg, r_right_reg);

28✔

4248

            off_reg = lower_array_off(lu, base_reg, wrap_reg, type, 0);

28✔

4250

         break;

28✔

4252

      case A_OTHERS:

1,298✔

4254

         continue;

1,298✔

4257

      if (stride != VCODE_INVALID_REG)

1,550✔

4258

         off_reg = emit_mul(off_reg, stride);

1,550✔

4260

      vcode_reg_t ptr_reg = emit_array_ref(mem_reg, off_reg);

1,550✔

4262

      if (value_regs[i] == VCODE_INVALID_REG) {

1,550✔

4264

         assert(tree_kind(value) == T_AGGREGATE);

60✔

4265

         value_regs[i] = lower_aggregate(lu, value, ptr_reg);

60✔

4268

      if (array_of_array && i > 0 && ndims == 1

1,550✔

4269

          && vcode_reg_kind(value_regs[0]) == VCODE_TYPE_UARRAY) {

745✔

4271

         vcode_reg_t locus = lower_debug_locus(a);

586✔

4272

         lower_check_array_sizes(lu, elem_type, elem_type,

586✔

4273

                                 value_regs[0], value_regs[i], locus);

586✔

4276

      if (count_reg != VCODE_INVALID_REG) {

1,550✔

4277

         vcode_reg_t src_reg = lower_array_data(value_regs[i]);

77✔

4278

         emit_copy(ptr_reg, src_reg, count_reg);

77✔

4280

      else if (array_of_array || multidim) {

1,473✔

4281

         assert(stride != VCODE_INVALID_REG);

819✔

4282

         vcode_reg_t src_reg = lower_array_data(value_regs[i]);

819✔

4283

         emit_copy(ptr_reg, src_reg, stride);

819✔

4285

      else if (type_is_record(elem_type))

654✔

4286

         emit_copy(ptr_reg, value_regs[i], VCODE_INVALID_REG);

145✔

4288

         emit_store_indirect(value_regs[i], ptr_reg);

509✔

4290

      if (loop_bb != VCODE_INVALID_BLOCK) {

1,550✔

4291

         assert(tree_subkind(a) == A_RANGE);

233✔

4292

         tree_t r = tree_range(a, 0);

233✔

4294

         vcode_type_t vtype = lower_type(tree_type(r));

233✔

4296

         vcode_reg_t r_dir_reg = lower_range_dir(lu, r);

233✔

4297

         vcode_reg_t step_down = emit_const(vtype, -1);

233✔

4298

         vcode_reg_t step_up   = emit_const(vtype, 1);

233✔

4299

         vcode_reg_t step_reg  = emit_select(r_dir_reg, step_down, step_up);

233✔

4300

         vcode_reg_t i_reg     = emit_load(tmp_var);

233✔

4301

         vcode_reg_t next_reg  = emit_add(i_reg, step_reg);

233✔

4302

         emit_store(next_reg, tmp_var);

233✔

4304

         vcode_reg_t r_right_reg = lower_range_right(lu, r);

233✔

4305

         vcode_reg_t done_reg    = emit_cmp(VCODE_CMP_EQ, i_reg, r_right_reg);

233✔

4306

         emit_cond(done_reg, exit_bb, loop_bb);

233✔

4308

         vcode_select_block(exit_bb);

233✔

4311

      if (tmp_var != VCODE_INVALID_VAR)

1,550✔

4312

         lower_release_temp(lu, tmp_var);

233✔

4315

   if (skip_bb != VCODE_INVALID_BLOCK) {

1,761✔

4316

      emit_jump(skip_bb);

1,146✔

4317

      vcode_select_block(skip_bb);

1,146✔

4323

static vcode_reg_t lower_aggregate(lower_unit_t *lu, tree_t expr,

7,853✔

4326

   type_t type = tree_type(expr);

7,853✔

4328

   if (type_is_record(type))

7,853✔

4329

      return lower_record_aggregate(lu, expr, false,

2,302✔

4330

                                    lower_is_const(expr), hint);

2,302✔

4331

   else if (type_is_array(type))

5,551✔

4332

      return lower_array_aggregate(lu, expr, hint);

5,551✔

4337

static vcode_reg_t lower_record_ref(lower_unit_t *lu, tree_t expr,

6,728✔

4340

   tree_t value = tree_value(expr);

6,728✔

4341

   type_t type = tree_type(value);

6,728✔

4342

   vcode_reg_t record = lower_expr(lu, value, ctx);

6,728✔

4344

   const int index = tree_pos(tree_ref(expr));

6,728✔

4345

   type_t ftype = tree_type(type_field(type, index));

6,728✔

4347

   vcode_reg_t f_reg = emit_record_ref(record, index);

6,728✔

4348

   if (lower_have_signal(f_reg) && type_is_homogeneous(ftype))

6,728✔

4349

      return emit_load_indirect(f_reg);

2,746✔

4350

   else if (type_is_array(ftype) && !type_const_bounds(ftype)) {

3,982✔

4353

      vcode_reg_t array = emit_load_indirect(f_reg);

707✔

4354

      if (type_const_bounds(tree_type(expr)))

707✔

4355

         return lower_array_data(array);

141✔

4360

      return f_reg;

3,275✔

4363

static vcode_reg_t lower_prot_ref(lower_unit_t *lu, tree_t expr)

12✔

4365

   assert(standard() >= STD_19);

12✔

4367

   vcode_reg_t prefix = lower_rvalue(lu, tree_value(expr));

12✔

4369

   vcode_type_t vtype = lower_type(tree_type(expr));

12✔

4370

   return emit_link_var(prefix, tree_ident(expr), vtype);

12✔

4373

static vcode_reg_t lower_protected_init(lower_unit_t *lu, type_t type,

163✔

4376

   vcode_reg_t names[2] = { VCODE_INVALID_REG, VCODE_INVALID_REG };

163✔

4378

   if (standard() >= STD_19) {

163✔

4381

      LOCAL_TEXT_BUF tb = tb_new();

76✔

4382

      static const attr_kind_t which[2] = {

38✔

4386

      for (int i = 0; i < 2; i++) {

114✔

4387

         tb_rewind(tb);

76✔

4388

         get_hierarchical_name(tb, lu, which[i]);

76✔

4389

         if (decl != NULL)

76✔

4390

            tb_istr(tb, tree_ident(decl));

58✔

4391

         tb_append(tb, ':');

76✔

4392

         tb_downcase(tb);

76✔

4394

         names[i] = lower_name_attr(lu, decl ?: lu->container, which[i]);

76✔

4398

   vcode_type_t vtype = lower_type(type);

163✔

4399

   vcode_reg_t context_reg = lower_context_for_call(lu, type_ident(type));

163✔

4400

   return emit_protected_init(vtype, context_reg, names[0], names[1]);

163✔

4403

static void lower_new_record(lower_unit_t *lu, type_t type,

973✔

4406

   if (src_ptr == dst_ptr)

973✔

4408

   else if (type_const_bounds(type))

718✔

4409

      emit_copy(dst_ptr, src_ptr, VCODE_INVALID_REG);

679✔

4411

      ident_t base_id = type_ident(type_base_recur(type));

39✔

4412

      ident_t helper_func = ident_prefix(base_id, ident_new("new"), '$');

39✔

4414

      vcode_reg_t args[] = {

39✔

4415

         lower_context_for_call(lu, helper_func),

39✔

4419

      emit_fcall(helper_func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

39✔

4424

static vcode_reg_t lower_new(lower_unit_t *lu, tree_t expr)

392✔

4426

   tree_t qual = tree_value(expr);

392✔

4427

   assert(tree_kind(qual) == T_QUALIFIED);

392✔

4429

   type_t type = tree_type(qual);

392✔

4431

   if (type_is_array(type)) {

392✔

4432

      type_t value_type = type, result_type = type_designated(tree_type(expr));

301✔

4433

      type_t elem = type_elem_recur(type);

301✔

4435

      const bool wrap_result = !type_const_bounds(result_type);

301✔

4436

      const bool wrap_value = !type_const_bounds(type);

301✔

4438

      type_t alloc_type = wrap_result ? result_type : elem;

301✔

4440

      vcode_reg_t init_reg = VCODE_INVALID_REG, bounds_reg = VCODE_INVALID_REG;

301✔

4441

      tree_t value = NULL;

301✔

4442

      if (tree_has_value(qual)) {

301✔

4443

         value = tree_value(qual);

178✔

4444

         value_type = tree_type(value);

178✔

4446

         const bool in_place_aggregate =

356✔

4447

            tree_kind(value) == T_AGGREGATE && type_const_bounds(value_type);

178✔

4449

         if (!in_place_aggregate)

178✔

4450

            init_reg = bounds_reg = lower_rvalue(lu, qual);

168✔

4452

      else if (wrap_value)

123✔

4453

         bounds_reg = lower_get_type_bounds(lu, type);

26✔

4455

      vcode_reg_t length_reg =

301✔

4456

         lower_array_total_len(lu, value_type, bounds_reg);

301✔

4457

      vcode_reg_t mem_reg = emit_new(lower_type(alloc_type), length_reg);

301✔

4458

      vcode_reg_t all_reg = emit_all(mem_reg);

301✔

4459

      vcode_reg_t data_reg = lower_array_data(all_reg);

301✔

4461

      vcode_reg_t array_reg = all_reg;

301✔

4462

      if (wrap_value)

301✔

4463

         array_reg = lower_wrap_with_new_bounds(lu, value_type, type,

177✔

4466

      if (value == NULL)

301✔

4467

         init_reg = lower_default_value(lu, type, array_reg);

123✔

4468

      else if (init_reg == VCODE_INVALID_REG)

178✔

4469

         init_reg = lower_aggregate(lu, value, data_reg);

10✔

4471

      if (init_reg != array_reg) {

301✔

4472

         vcode_reg_t src_reg = lower_array_data(init_reg);

187✔

4473

         emit_copy(data_reg, src_reg, length_reg);

187✔

4476

      if (wrap_result) {

301✔

4478

         vcode_reg_t meta_reg =

244✔

4479

            lower_wrap_with_new_bounds(lu, value_type, result_type,

244✔

4481

         emit_store_indirect(meta_reg, all_reg);

244✔

4484

      return mem_reg;

301✔

4486

   else if (type_is_record(type)) {

91✔

4487

      vcode_reg_t result_reg =

54✔

4488

         emit_new(lower_type(type), VCODE_INVALID_REG);

54✔

4489

      vcode_reg_t all_reg = emit_all(result_reg);

54✔

4491

      vcode_reg_t init_reg;

54✔

4492

      if (tree_has_value(qual)) {

54✔

4493

         tree_t value = tree_value(qual);

19✔

4494

         if (tree_kind(value) == T_AGGREGATE && type_const_bounds(type))

19✔

4495

            init_reg = lower_aggregate(lu, value, all_reg);

4✔

4497

            init_reg = lower_rvalue(lu, qual);

15✔

4500

         init_reg = lower_default_value(lu, type, all_reg);

35✔

4502

      lower_new_record(lu, type, all_reg, init_reg);

54✔

4503

      return result_reg;

54✔

4505

   else if (type_is_protected(type)) {

37✔

4506

      vcode_reg_t obj_reg = lower_protected_init(lu, type, NULL);

9✔

4507

      vcode_reg_t result_reg = emit_new(lower_type(type), VCODE_INVALID_REG);

9✔

4508

      vcode_reg_t all_reg = emit_all(result_reg);

9✔

4509

      emit_store_indirect(obj_reg, all_reg);

9✔

4510

      return result_reg;

9✔

4513

      vcode_reg_t result_reg = emit_new(lower_type(type), VCODE_INVALID_REG);

28✔

4514

      vcode_reg_t all_reg = emit_all(result_reg);

28✔

4516

      vcode_reg_t init_reg;

28✔

4517

      if (tree_has_value(qual))

28✔

4518

         init_reg = lower_rvalue(lu, qual);

18✔

4520

         init_reg = lower_default_value(lu, type, VCODE_INVALID_REG);

10✔

4522

      emit_store_indirect(init_reg, all_reg);

28✔

4523

      return result_reg;

28✔

4527

static vcode_reg_t lower_incomplete_access(vcode_reg_t in_reg, type_t type)

3,056✔

4529

   assert(vcode_reg_kind(in_reg) == VCODE_TYPE_ACCESS);

3,056✔

4531

   vcode_type_t pointed = vtype_pointed(vcode_reg_type(in_reg));

3,056✔

4533

   const bool have_opaque = vtype_kind(pointed) == VCODE_TYPE_OPAQUE;

3,056✔

4534

   const bool have_incomplete = type_is_incomplete(type);

3,056✔

4536

   if (have_incomplete ^ have_opaque) {

3,056✔

4537

      vcode_type_t ptr_type = vtype_access(lower_type(type));

474✔

4538

      return emit_cast(ptr_type, ptr_type, in_reg);

474✔

4544

static vcode_reg_t lower_all(lower_unit_t *lu, tree_t all, expr_ctx_t ctx)

1,755✔

4546

   type_t type = tree_type(all);

1,755✔

4547

   vcode_reg_t access_reg = lower_rvalue(lu, tree_value(all));

1,755✔

4548

   emit_null_check(access_reg, lower_debug_locus(all));

1,755✔

4549

   access_reg = lower_incomplete_access(access_reg, tree_type(all));

1,755✔

4550

   vcode_reg_t all_reg = emit_all(access_reg);

1,755✔

4552

   if (type_is_array(type) && !type_const_bounds(type))

1,755✔

4553

      return emit_load_indirect(all_reg);

776✔

4555

      return all_reg;

979✔

4558

static void lower_convert_record(lower_unit_t *lu, vcode_reg_t value_reg,

15✔

4562

   const int to_nf = type_fields(to);

15✔

4563

   const int from_nf = type_fields(from);

15✔

4565

   for (int i = 0; i < to_nf; i++) {

51✔

4566

      tree_t to_f = type_field(to, i);

36✔

4567

      type_t to_type = tree_type(to_f), from_type = NULL;

36✔

4568

      ident_t name = tree_ident(to_f);

36✔

4570

      vcode_reg_t from_reg = VCODE_INVALID_REG;

36✔

4571

      for (int j = 0; j < from_nf; j++) {

63✔

4572

         tree_t f = type_field(from, j);

63✔

4573

         if (tree_ident(f) == name) {

63✔

4574

            from_reg = emit_record_ref(value_reg, j);

36✔

4575

            from_type = tree_type(f);

36✔

4576

            break;

36✔

4579

      assert(from_reg != VCODE_INVALID_REG);

36✔

4581

      if (have_uarray_ptr(from_reg))

36✔

4582

         from_reg = emit_load_indirect(from_reg);

3✔

4584

      vcode_reg_t to_reg = emit_record_ref(ptr_reg, i);

36✔

4586

      if (type_is_array(to_type)) {

36✔

4587

         vcode_reg_t conv_reg =

6✔

4588

            lower_conversion(lu, from_reg, where, from_type, to_type);

6✔

4592

         if (have_uarray_ptr(to_reg)) {

6✔

4593

            assert(vcode_reg_kind(conv_reg) == VCODE_TYPE_UARRAY);

3✔

4594

            emit_store_indirect(conv_reg, to_reg);

3✔

4597

            vcode_reg_t data_reg = lower_array_data(conv_reg);

3✔

4598

            vcode_reg_t count_reg =

3✔

4599

               lower_array_total_len(lu, to_type, conv_reg);

3✔

4600

            emit_copy(to_reg, data_reg, count_reg);

3✔

4603

      else if (type_is_record(to_type))

30✔

4604

         lower_convert_record(lu, from_reg, where, from_type, to_type, to_reg);

6✔

4606

         vcode_reg_t elem_reg = emit_load_indirect(from_reg);

24✔

4607

         vcode_reg_t conv_reg =

24✔

4608

            lower_conversion(lu, elem_reg, where, from_type, to_type);

24✔

4609

         emit_store_indirect(conv_reg, to_reg);

24✔

4612

15✔

4614

static vcode_reg_t lower_conversion(lower_unit_t *lu, vcode_reg_t value_reg,

4,332✔

4617

   type_kind_t from_k = type_kind(type_base_recur(from));

4,332✔

4618

   type_kind_t to_k   = type_kind(type_base_recur(to));

4,332✔

4620

   if (from_k == T_REAL && to_k == T_INTEGER) {

4,332✔

4621

      vcode_type_t vtype = lower_type(to);

91✔

4622

      vcode_type_t vbounds = vtype_int(INT64_MIN, INT64_MAX);

91✔

4623

      vcode_reg_t cast = emit_cast(vtype, vbounds, value_reg);

91✔

4624

      lower_check_scalar_bounds(lu, cast, to, where, NULL);

91✔

4625

      return cast;

91✔

4627

   else if (from_k == T_INTEGER && to_k == T_REAL) {

4,241✔

4628

      vcode_type_t vtype = lower_type(to);

179✔

4629

      vcode_type_t vbounds = vtype_real((double)INT64_MIN, (double)INT64_MAX);

179✔

4630

      return emit_cast(vtype, vbounds, value_reg);

179✔

4632

   else if (from_k == T_ARRAY && to_k == T_ARRAY) {

4,062✔

4633

      type_t from_e = type_elem_recur(from);

2,462✔

4634

      type_t to_e = type_elem_recur(to);

2,462✔

4636

      vcode_reg_t result_reg = value_reg;

2,462✔

4638

      if (standard() >= STD_08 && !type_eq(from_e, to_e)) {

2,462✔

4642

         vcode_type_t velem = lower_type(to_e);

15✔

4643

         vcode_type_t vbounds = lower_bounds(from_e);

15✔

4644

         vcode_type_t voffset = vtype_offset();

15✔

4646

         vcode_reg_t count_reg = lower_array_total_len(lu, from, value_reg);

15✔

4647

         vcode_reg_t mem_reg = emit_alloc(velem, vbounds, count_reg);

15✔

4648

         vcode_reg_t zero_reg = emit_const(voffset, 0);

15✔

4649

         vcode_reg_t data_reg = lower_array_data(value_reg);

15✔

4651

         vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

15✔

4652

         emit_store(zero_reg, i_var);

15✔

4654

         vcode_block_t body_bb = emit_block();

15✔

4655

         vcode_block_t exit_bb = emit_block();

15✔

4657

         vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg);

15✔

4658

         emit_cond(null_reg, exit_bb, body_bb);

15✔

4660

         vcode_select_block(body_bb);

15✔

4662

         vcode_reg_t i_reg = emit_load(i_var);

15✔

4663

         vcode_reg_t src_reg = emit_array_ref(data_reg, i_reg);

15✔

4664

         vcode_reg_t elem_reg = emit_load_indirect(src_reg);

15✔

4666

         vcode_reg_t conv_reg =

15✔

4667

            lower_conversion(lu, elem_reg, where, from_e, to_e);

15✔

4669

         vcode_reg_t dest_reg = emit_array_ref(mem_reg, i_reg);

15✔

4670

         emit_store_indirect(conv_reg, dest_reg);

15✔

4672

         vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1));

15✔

4673

         vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count_reg);

15✔

4674

         emit_store(next_reg, i_var);

15✔

4675

         emit_cond(done_reg, exit_bb, body_bb);

15✔

4677

         vcode_select_block(exit_bb);

15✔

4679

         lower_release_temp(lu, i_var);

15✔

4681

         result_reg = mem_reg;

15✔

4684

      if (!type_const_bounds(to))   // Need to wrap in metadata

2,462✔

4685

         result_reg = lower_wrap(lu, from, result_reg);

2,432✔

4687

      if (type_is_unconstrained(to))

2,462✔

4688

         lower_check_indexes(lu, from, to, result_reg, where);

2,418✔

4690

         vcode_reg_t locus = lower_debug_locus(where);

44✔

4691

         lower_check_array_sizes(lu, to, from, value_reg, result_reg, locus);

44✔

4694

      return result_reg;

2,462✔

4696

   else if ((from_k == T_INTEGER && to_k == T_INTEGER)

1,600✔

4697

            || (from_k == T_REAL && to_k == T_REAL)) {

51✔

4699

      lower_check_scalar_bounds(lu, value_reg, to, where, NULL);

1,571✔

4700

      return emit_cast(lower_type(to), lower_bounds(to), value_reg);

1,571✔

4702

   else if (from_k == T_RECORD && to_k == T_RECORD) {

29✔

4703

      vcode_type_t vtype_to = lower_type(to);

9✔

4704

      vcode_var_t tmp_var = lower_temp_var(lu, "conv", vtype_to, vtype_to);

9✔

4705

      vcode_reg_t ptr_reg = emit_index(tmp_var, VCODE_INVALID_REG);

9✔

4706

      lower_convert_record(lu, value_reg, where, from, to, ptr_reg);

9✔

4707

      return ptr_reg;

9✔

4715

static vcode_reg_t lower_type_conv(lower_unit_t *lu, tree_t expr)

4,263✔

4717

   tree_t value = tree_value(expr);

4,263✔

4719

   type_t from = tree_type(value);

4,263✔

4720

   type_t to   = tree_type(expr);

4,263✔

4722

   vcode_reg_t value_reg = lower_rvalue(lu, value);

4,263✔

4723

   return lower_conversion(lu, value_reg, expr, from, to);

4,263✔

4726

static vcode_reg_t lower_driving_value(lower_unit_t *lu, tree_t name)

134✔

4728

   vcode_reg_t name_reg = lower_lvalue(lu, name);

134✔

4730

   type_t name_type = tree_type(name);

134✔

4731

   if (type_is_homogeneous(name_type)) {

134✔

4732

      if (type_is_array(name_type)) {

128✔

4733

         vcode_reg_t len_reg = lower_array_total_len(lu, name_type, name_reg);

30✔

4734

         vcode_reg_t ptr_reg = emit_driving_value(name_reg, len_reg);

30✔

4735

         if (vcode_reg_kind(name_reg) == VCODE_TYPE_UARRAY)

30✔

4741

         vcode_reg_t ptr_reg = emit_driving_value(name_reg, VCODE_INVALID_REG);

98✔

4742

         return emit_load_indirect(ptr_reg);

98✔

4746

      type_t base = type_base_recur(name_type);

6✔

4747

      ident_t base_id = type_ident(base);

6✔

4748

      ident_t helper_func = ident_prefix(base_id, ident_new("driving"), '$');

6✔

4750

      vcode_reg_t arg_reg;

6✔

4751

      if (type_is_array(base))

6✔

4756

      vcode_type_t vrtype = lower_func_result_type(base);

6✔

4758

      vcode_reg_t context_reg = lower_context_for_call(lu, helper_func);

6✔

4759

      vcode_reg_t args[] = { context_reg, arg_reg };

6✔

4760

      return emit_fcall(helper_func, vrtype, vrtype, args, 2);

6✔

4764

static const int lower_get_attr_dimension(tree_t expr)

11,238✔

4766

   if (tree_params(expr) > 0)

11,238✔

4767

      return assume_int(tree_value(tree_param(expr, 0))) - 1;

24✔

4772

static vcode_reg_t lower_attr_prefix(lower_unit_t *lu, tree_t prefix)

16,419✔

4774

   switch (class_of(prefix)) {

16,419✔

4775

   case C_SIGNAL:

879✔

4777

         vcode_reg_t reg = lower_lvalue(lu, prefix);

879✔

4778

         if (have_uarray_ptr(reg))

879✔

4786

   default:

14,799✔

4787

      return lower_rvalue(lu, prefix);

14,799✔

4791

static vcode_reg_t lower_reflect_attr(lower_unit_t *lu, tree_t expr)

87✔

4793

   tree_t name = tree_name(expr);

87✔

4794

   type_t type = tree_type(expr);

87✔

4796

   ident_t init_func = type_ident(type);

87✔

4797

   vcode_reg_t context_reg = lower_context_for_call(lu, init_func);

87✔

4799

   type_t value_mirror = reflection_type(REFLECT_VALUE_MIRROR);

87✔

4800

   const bool is_value_mirror = type_eq(type, value_mirror);

87✔

4802

   vcode_reg_t value_reg = VCODE_INVALID_REG, bounds_reg = VCODE_INVALID_REG;

87✔

4803

   if (is_value_mirror)

87✔

4804

      value_reg = lower_attr_prefix(lu, name);

45✔

4806

   type_t value_type = tree_type(name);

87✔

4807

   if (type_is_array(value_type))

87✔

4808

      bounds_reg = lower_wrap(lu, value_type, value_reg);

6✔

4810

   vcode_reg_t locus = lower_debug_locus(name);

87✔

4812

   if (is_value_mirror)

87✔

4813

      return emit_reflect_value(value_reg, context_reg, locus, bounds_reg);

45✔

4815

      return emit_reflect_subtype(context_reg, locus, bounds_reg);

42✔

4818

static vcode_reg_t lower_attr_param(lower_unit_t *lu, tree_t value,

1,305✔

4821

   type_t value_type = tree_type(value);

1,305✔

4823

   vcode_reg_t reg;

1,305✔

4824

   if (class == C_SIGNAL || class == C_FILE)

1,305✔

4827

      reg = lower_rvalue(lu, value);

1,305✔

4829

   if (reg == VCODE_INVALID_REG)

1,305✔

4832

   if (type_is_array(value_type))

1,305✔

4833

      return lower_coerce_arrays(lu, value_type, port_type ?: value_type, reg);

21✔

4840

static vcode_reg_t lower_attr_ref(lower_unit_t *lu, tree_t expr)

14,259✔

4842

   tree_t name = tree_name(expr);

14,259✔

4844

   const attr_kind_t predef = tree_subkind(expr);

14,259✔

4845

   switch (predef) {

14,259✔

4846

   case ATTR_LEFT:

1,099✔

4849

         const int dim = lower_get_attr_dimension(expr);

1,099✔

4851

         type_t type = tree_type(name);

1,099✔

4852

         if (type_is_unconstrained(type)) {

1,099✔

4853

            vcode_reg_t array_reg = lower_attr_prefix(lu, name);

596✔

4854

            if (predef == ATTR_LEFT)

596✔

4855

               return lower_array_left(lu, type, dim, array_reg);

447✔

4857

               return lower_array_right(lu, type, dim, array_reg);

149✔

4860

            tree_t r = range_of(type, dim);

503✔

4861

            if (predef == ATTR_LEFT)

503✔

4862

               return lower_range_left(lu, r);

469✔

4864

               return lower_range_right(lu, r);

34✔

4868

   case ATTR_LOW:

4,444✔

4871

         const int dim = lower_get_attr_dimension(expr);

4,444✔

4873

         vcode_reg_t left_reg  = VCODE_INVALID_REG;

4,444✔

4874

         vcode_reg_t right_reg = VCODE_INVALID_REG;

4,444✔

4875

         vcode_reg_t dir_reg   = VCODE_INVALID_REG;

4,444✔

4877

         type_t type = tree_type(name);

4,444✔

4878

         if (type_is_unconstrained(type)) {

4,444✔

4879

            vcode_reg_t array_reg = lower_attr_prefix(lu, name);

3,515✔

4880

            left_reg  = lower_array_left(lu, type, dim, array_reg);

3,515✔

4881

            right_reg = lower_array_right(lu, type, dim, array_reg);

3,515✔

4882

            dir_reg   = lower_array_dir(lu, type, dim, array_reg);

3,515✔

4885

            tree_t r = range_of(type, dim);

929✔

4886

            const range_kind_t rkind = tree_subkind(r);

929✔

4887

            if (rkind == RANGE_TO) {

929✔

4888

               return predef == ATTR_LOW

281✔

4889

                  ? lower_range_left(lu, r) : lower_range_right(lu, r);

281✔

4891

            else if (rkind == RANGE_DOWNTO) {

648✔

4892

               return predef == ATTR_LOW

506✔

4893

                  ? lower_range_right(lu, r) : lower_range_left(lu, r);

506✔

4896

            left_reg  = lower_range_left(lu, r);

142✔

4897

            right_reg = lower_range_right(lu, r);

142✔

4898

            dir_reg   = lower_range_dir(lu, r);

142✔

4901

         if (predef == ATTR_LOW)

3,657✔

4902

            return emit_select(dir_reg, right_reg, left_reg);

1,830✔

4904

            return emit_select(dir_reg, left_reg, right_reg);

1,827✔

4907

   case ATTR_LENGTH:

5,644✔

4909

         const int dim = lower_get_attr_dimension(expr);

5,644✔

4910

         vcode_reg_t name_reg = lower_attr_prefix(lu, name);

5,644✔

4911

         vcode_reg_t len_reg =

5,644✔

4912

            lower_array_len(lu, tree_type(name), dim, name_reg);

5,644✔

4913

         return emit_cast(lower_type(tree_type(expr)),

5,644✔

4917

   case ATTR_ELEMENT:

24✔

4919

         vcode_reg_t array_reg = lower_attr_prefix(lu, name);

24✔

4920

         type_t type = tree_type(name);

24✔

4921

         type_t elem = type_elem_recur(type);

24✔

4922

         vcode_reg_t null_reg = emit_null(vtype_pointer(lower_type(elem)));

24✔

4923

         return lower_wrap_element(lu, type, array_reg, null_reg);

24✔

4926

   case ATTR_ASCENDING:

51✔

4928

         type_t type = tree_type(name);

51✔

4929

         const int dim = lower_get_attr_dimension(expr);

51✔

4930

         if (type_const_bounds(type))

51✔

4934

            vcode_reg_t name_reg = lower_attr_prefix(lu, name);

51✔

4935

            return emit_not(lower_array_dir(lu, type, dim, name_reg));

51✔

4939

   case ATTR_LAST_EVENT:

72✔

4942

         vcode_reg_t name_reg = lower_attr_prefix(lu, name);

72✔

4943

         type_t name_type = tree_type(name);

72✔

4945

         if (type_is_homogeneous(name_type)) {

72✔

4946

            vcode_reg_t len_reg = VCODE_INVALID_REG;

51✔

4947

            if (type_is_array(name_type)) {

51✔

4948

               len_reg = lower_array_total_len(lu, name_type, name_reg);

15✔

4949

               name_reg = lower_array_data(name_reg);

15✔

4952

            if (predef == ATTR_LAST_EVENT)

51✔

4953

               return emit_last_event(name_reg, len_reg);

24✔

4955

               return emit_last_active(name_reg, len_reg);

27✔

4958

            ident_t base_id = type_ident(type_base_recur(name_type));

21✔

4959

            const char *suffix = predef == ATTR_LAST_EVENT

42✔

4960

               ? "last_event" : "last_active";

21✔

4961

            ident_t helper_func = ident_sprintf("%s$%s", istr(base_id), suffix);

21✔

4963

            vcode_reg_t arg_reg = name_reg;

21✔

4964

            if (type_is_array(name_type)

21✔

4968

            vcode_type_t vtime = vtype_time();

21✔

4969

            vcode_reg_t context_reg = lower_context_for_call(lu, helper_func);

21✔

4970

            vcode_reg_t args[] = { context_reg, arg_reg };

21✔

4971

            return emit_fcall(helper_func, vtime, vtime, args, 2);

21✔

4975

   case ATTR_DRIVING_VALUE:

27✔

4976

      return lower_driving_value(lu, name);

27✔

4978

   case ATTR_EVENT:

250✔

4979

      return lower_signal_flag(lu, name, emit_event_flag);

250✔

4981

   case ATTR_ACTIVE:

208✔

4982

      return lower_signal_flag(lu, name, emit_active_flag);

208✔

4984

   case ATTR_DRIVING:

36✔

4985

      return lower_signal_flag(lu, name, emit_driving_flag);

36✔

4987

   case ATTR_LAST_VALUE:

53✔

4988

      return lower_last_value(lu, name);

53✔

4990

   case ATTR_INSTANCE_NAME:

765✔

4992

      if (lu->mode == LOWER_THUNK) {

765✔

4998

         return lower_name_attr(lu, tree_ref(name), predef);

765✔

5000

   case ATTR_SIMPLE_NAME:

69✔

5002

         LOCAL_TEXT_BUF tb = tb_new();

138✔

5003

         tb_istr(tb, tree_ident(tree_ref(name)));

69✔

5004

         tb_downcase(tb);

69✔

5005

         return lower_wrap_string(tb_get(tb));

69✔

5008

   case ATTR_IMAGE:

1,006✔

5010

         tree_t value = tree_value(tree_param(expr, 0));

1,006✔

5011

         type_t type = tree_type(value);

1,006✔

5012

         type_t base = type_base_recur(type);

1,006✔

5013

         ident_t func = ident_prefix(type_ident(base), ident_new("image"), '$');

1,006✔

5014

         vcode_type_t ctype = vtype_char();

1,006✔

5015

         vcode_type_t strtype = vtype_uarray(1, ctype, ctype);

1,006✔

5017

         vcode_reg_t arg_reg = lower_attr_param(lu, value, base, C_CONSTANT);

1,006✔

5019

         vcode_reg_t args[] = {

1,006✔

5020

            lower_context_for_call(lu, func),

1,006✔

5023

         return emit_fcall(func, strtype, strtype, args, 2);

1,006✔

5026

   case ATTR_VALUE:

125✔

5028

         type_t name_type = tree_type(name);

125✔

5029

         tree_t value = tree_value(tree_param(expr, 0));

125✔

5030

         type_t value_type = tree_type(value);

125✔

5032

         vcode_reg_t value_reg = lower_rvalue(lu, value);

125✔

5034

         if (lower_have_signal(value_reg))

125✔

5037

         if (vcode_reg_kind(value_reg) != VCODE_TYPE_UARRAY)

125✔

5038

            value_reg = lower_wrap(lu, value_type, value_reg);

105✔

5040

         type_t base = type_base_recur(name_type);

125✔

5041

         ident_t func = ident_prefix(type_ident(base), ident_new("value"), '$');

125✔

5042

         vcode_reg_t args[] = {

125✔

5043

            lower_context_for_call(lu, func),

125✔

5046

         vcode_reg_t reg = emit_fcall(func, lower_type(base),

125✔

5049

         if (type_is_scalar(name_type))

125✔

5050

            lower_check_scalar_bounds(lu, reg, name_type, expr, NULL);

95✔

5051

         else if (type_is_array(name_type) && type_const_bounds(name_type)) {

30✔

5052

            vcode_reg_t locus = lower_debug_locus(expr);

6✔

5053

            lower_check_array_sizes(lu, name_type, base, VCODE_INVALID_REG,

6✔

5057

         return reg;

125✔

5060

   case ATTR_SUCC:

4✔

5062

         tree_t value = tree_value(tree_param(expr, 0));

4✔

5063

         vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT);

4✔

5064

         return emit_add(arg_reg, emit_const(vcode_reg_type(arg_reg), 1));

4✔

5067

   case ATTR_PRED:

13✔

5069

         tree_t value = tree_value(tree_param(expr, 0));

13✔

5070

         vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT);

13✔

5071

         return emit_sub(arg_reg, emit_const(vcode_reg_type(arg_reg), 1));

13✔

5074

   case ATTR_LEFTOF:

14✔

5076

         tree_t value = tree_value(tree_param(expr, 0));

14✔

5077

         vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT);

14✔

5079

         type_t type = tree_type(expr);

14✔

5080

         const int dir =

28✔

5081

            (type_is_enum(type) || direction_of(type, 0) == RANGE_TO) ? -1 : 1;

14✔

5082

         return emit_add(arg_reg, emit_const(vcode_reg_type(arg_reg), dir));

14✔

5085

   case ATTR_RIGHTOF:

11✔

5087

         tree_t value = tree_value(tree_param(expr, 0));

11✔

5088

         vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT);

11✔

5090

         type_t type = tree_type(expr);

11✔

5091

         const int dir =

22✔

5092

            (type_is_enum(type) || direction_of(type, 0) == RANGE_TO) ? 1 : -1;

11✔

5093

         return emit_add(arg_reg, emit_const(vcode_reg_type(arg_reg), dir));

11✔

5096

   case ATTR_POS:

97✔

5098

         tree_t value = tree_value(tree_param(expr, 0));

97✔

5099

         vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT);

97✔

5101

         type_t type = tree_type(expr);

97✔

5102

         return emit_cast(lower_type(type), lower_bounds(type), arg_reg);

97✔

5105

   case ATTR_VAL:

160✔

5107

         tree_t value = tree_value(tree_param(expr, 0));

160✔

5108

         vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT);

160✔

5110

         type_t type = tree_type(expr);

160✔

5111

         lower_check_scalar_bounds(lu, arg_reg, type, expr, NULL);

160✔

5112

         return emit_cast(lower_type(type), lower_bounds(type), arg_reg);

160✔

5115

   case ATTR_REFLECT:

87✔

5116

      return lower_reflect_attr(lu, expr);

87✔

5124

static vcode_reg_t lower_qualified(lower_unit_t *lu, tree_t expr)

4,251✔

5126

   tree_t value = tree_value(expr);

4,251✔

5128

   type_t from_type = tree_type(value);

4,251✔

5129

   type_t to_type = tree_type(expr);

4,251✔

5131

   vcode_reg_t value_reg = lower_rvalue(lu, value);

4,251✔

5133

   if (type_is_array(to_type))

4,251✔

5134

      return lower_coerce_arrays(lu, from_type, to_type, value_reg);

3,160✔

5139

static vcode_reg_t lower_cond_value(lower_unit_t *lu, tree_t expr)

9✔

5141

   vcode_block_t exit_bb = VCODE_INVALID_BLOCK;

9✔

5144

   type_t type = tree_type(expr);

9✔

5145

   vcode_type_t vtype = lower_type(type);

9✔

5146

   vcode_type_t vbounds = lower_bounds(type);

9✔

5147

   vcode_var_t temp_var = lower_temp_var(lu, "cond", vtype, vbounds);

9✔

5149

   const int nconds = tree_conds(expr);

9✔

5150

   for (int i = 0; i < nconds; i++) {

21✔

5151

      tree_t c = tree_cond(expr, i);

21✔

5152

      assert(tree_kind(c) == T_COND_EXPR);

21✔

5154

      vcode_block_t next_bb = VCODE_INVALID_BLOCK;

21✔

5156

      if (tree_has_value(c)) {

21✔

5157

         vcode_reg_t test = lower_rvalue(lu, tree_value(c));

12✔

5159

         vcode_block_t btrue = emit_block();

12✔

5161

         if (i == nconds - 1) {

12✔

5167

            next_bb = emit_block();

12✔

5169

         emit_cond(test, btrue, next_bb);

12✔

5170

         vcode_select_block(btrue);

12✔

5173

      vcode_reg_t result_reg = lower_rvalue(lu, tree_result(c));

21✔

5175

      if (type_is_array(type) && type_const_bounds(type)) {

27✔

5176

         vcode_reg_t count_reg =

6✔

5177

            lower_array_total_len(lu, type, VCODE_INVALID_REG);

6✔

5178

         vcode_reg_t dest_reg = emit_index(temp_var, VCODE_INVALID_REG);

6✔

5179

         vcode_reg_t src_reg = lower_array_data(result_reg);

6✔

5180

         emit_copy(dest_reg, src_reg, count_reg);

6✔

5182

      else if (type_is_record(type)) {

15✔

5183

         vcode_reg_t dest_reg = emit_index(temp_var, VCODE_INVALID_REG);

9✔

5184

         emit_copy(dest_reg, result_reg, VCODE_INVALID_REG);

9✔

5187

         emit_store(result_reg, temp_var);

6✔

5189

      if (exit_bb == VCODE_INVALID_BLOCK)

21✔

5190

         exit_bb = emit_block();

9✔

5191

      emit_jump(exit_bb);

21✔

5193

      if (next_bb == VCODE_INVALID_BLOCK)

21✔

5196

         vcode_select_block(next_bb);

12✔

5199

   if (exit_bb != VCODE_INVALID_BLOCK)

9✔

5200

      vcode_select_block(exit_bb);

9✔

5202

   if (type_is_scalar(type))

9✔

5203

      return emit_load(temp_var);

3✔

5205

      return emit_index(temp_var, VCODE_INVALID_REG);

6✔

5208

static vcode_reg_t lower_expr(lower_unit_t *lu, tree_t expr, expr_ctx_t ctx)

525,497✔

5210

   PUSH_DEBUG_INFO(expr);

1,050,994✔

5212

   switch (tree_kind(expr)) {

525,497✔

5213

   case T_FCALL:

65,939✔

5215

      return lower_fcall(lu, expr, VCODE_INVALID_REG);

65,939✔

5216

   case T_PSL_FCALL:

36✔

5217

      return psl_lower_fcall(lu, tree_psl(expr));

36✔

5218

   case T_LITERAL:

178,947✔

5219

      return lower_literal(expr);

178,947✔

5220

   case T_STRING:

19,740✔

5221

      return lower_string_literal(expr, false);

19,740✔

5222

   case T_REF:

204,054✔

5223

      return lower_ref(lu, expr, ctx);

204,054✔

5224

   case T_EXTERNAL_NAME:

161✔

5225

      return lower_external_name(lu, expr);

161✔

5226

   case T_AGGREGATE:

4,157✔

5227

      return lower_aggregate(lu, expr, VCODE_INVALID_VAR);

4,157✔

5228

   case T_ARRAY_REF:

18,152✔

5229

      return lower_array_ref(lu, expr, ctx);

18,152✔

5230

   case T_ARRAY_SLICE:

2,641✔

5231

      return lower_array_slice(lu, expr, ctx);

2,641✔

5232

   case T_RECORD_REF:

6,728✔

5233

      return lower_record_ref(lu, expr, ctx);

6,728✔

5234

   case T_PROT_REF:

12✔

5235

      return lower_prot_ref(lu, expr);

12✔

5236

   case T_NEW:

392✔

5237

      return lower_new(lu, expr);

392✔

5238

   case T_ALL:

1,755✔

5239

      return lower_all(lu, expr, ctx);

1,755✔

5240

   case T_TYPE_CONV:

4,263✔

5241

      return lower_type_conv(lu, expr);

4,263✔

5242

   case T_ATTR_REF:

14,259✔

5243

      return lower_attr_ref(lu, expr);

14,259✔

5244

   case T_QUALIFIED:

4,251✔

5245

      return lower_qualified(lu, expr);

4,251✔

5248

   case T_COND_VALUE:

9✔

5249

      return lower_cond_value(lu, expr);

9✔

5256

static vcode_reg_t lower_nested_default_value(lower_unit_t *lu, type_t type)

4,310✔

5258

   if (type_is_scalar(type))

4,310✔

5259

      return lower_scalar_type_left(lu, type);

3,151✔

5260

   else if (type_is_array(type)) {

1,159✔

5261

      assert(type_const_bounds(type));

521✔

5262

      type_t elem = type_elem_recur(type);

521✔

5263

      vcode_reg_t elem_reg = lower_nested_default_value(lu, elem);

521✔

5264

      const int size = lower_array_const_size(type);

521✔

5266

      if (vtype_is_scalar(vcode_reg_type(elem_reg)))

521✔

5267

         return emit_const_rep(lower_type(type), elem_reg, size);

471✔

5269

         vcode_reg_t *values LOCAL = xmalloc_array(size, sizeof(vcode_reg_t));

100✔

5270

         for (int i = 0; i < size; i++)

400✔

5271

            values[i] = elem_reg;

350✔

5272

         return emit_const_array(lower_type(type), values, size);

50✔

5275

   else if (type_is_record(type)) {

638✔

5276

      assert(type_const_bounds(type));

583✔

5277

      const int nfields = type_fields(type);

583✔

5278

      vcode_type_t vtype = lower_type(type);

583✔

5280

      vcode_reg_t *values LOCAL = xmalloc_array(nfields, sizeof(vcode_reg_t));

1,166✔

5281

      for (int i = 0; i < nfields; i++) {

2,432✔

5282

         type_t ftype = tree_type(type_field(type, i));

1,849✔

5283

         values[i] = lower_nested_default_value(lu, ftype);

1,849✔

5286

      return emit_const_record(vtype, values, nfields);

583✔

5288

   else if (type_is_access(type))

55✔

5289

      return emit_null(lower_type(type));

55✔

5295

static vcode_reg_t lower_default_value(lower_unit_t *lu, type_t type,

11,004✔

5298

   if (type_is_scalar(type))

11,004✔

5299

      return lower_scalar_type_left(lu, type);

5,314✔

5300

   else if (type_is_array(type)) {

5,690✔

5301

      assert(!type_is_unconstrained(type));

4,477✔

5303

      type_t elem_type = type_elem_recur(type);

4,477✔

5305

      if (type_const_bounds(type)) {

4,477✔

5306

         if (type_is_scalar(elem_type)) {

1,548✔

5307

            vcode_reg_t elem_reg = lower_nested_default_value(lu, elem_type);

1,507✔

5308

            const int size = lower_array_const_size(type);

1,507✔

5309

            if (hint_reg == VCODE_INVALID_REG) {

1,507✔

5310

               vcode_type_t vtype = lower_type(type);

18✔

5311

               return emit_address_of(emit_const_rep(vtype, elem_reg, size));

18✔

5314

               vcode_reg_t count_reg = emit_const(vtype_offset(), size);

1,489✔

5315

               vcode_reg_t data_reg = lower_array_data(hint_reg);

1,489✔

5316

               emit_memset(data_reg, elem_reg, count_reg);

1,489✔

5317

               return hint_reg;

1,489✔

5321

            return emit_address_of(lower_nested_default_value(lu, type));

41✔

5324

      vcode_reg_t count_reg = lower_array_total_len(lu, type, hint_reg);

2,929✔

5325

      vcode_reg_t def_reg =

2,929✔

5326

         lower_default_value(lu, elem_type, VCODE_INVALID_REG);

2,929✔

5328

      if (hint_reg == VCODE_INVALID_REG) {

2,929✔

5334

      vcode_reg_t data_reg = lower_array_data(hint_reg);

2,929✔

5336

      if (type_is_scalar(elem_type))

2,929✔

5337

         emit_memset(data_reg, def_reg, count_reg);

2,882✔

5340

         vcode_type_t voffset = vtype_offset();

47✔

5341

         vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

47✔

5342

         emit_store(emit_const(voffset, 0), i_var);

47✔

5344

         vcode_block_t body_bb = emit_block();

47✔

5345

         vcode_block_t exit_bb = emit_block();

47✔

5347

         vcode_block_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg,

47✔

5349

         emit_cond(null_reg, exit_bb, body_bb);

47✔

5351

         vcode_select_block(body_bb);

47✔

5353

         vcode_reg_t i_reg = emit_load(i_var);

47✔

5354

         vcode_reg_t ptr_reg = emit_array_ref(data_reg, i_reg);

47✔

5356

         if (type_is_scalar(elem_type))

47✔

5358

         else if (type_is_record(elem_type))

47✔

5359

            lower_new_record(lu, elem_type, ptr_reg, def_reg);

47✔

5363

         vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1));

47✔

5364

         emit_store(next_reg, i_var);

47✔

5366

         vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count_reg);

47✔

5367

         emit_cond(done_reg, exit_bb, body_bb);

47✔

5369

         vcode_select_block(exit_bb);

47✔

5370

         lower_release_temp(lu, i_var);

47✔

5373

      return hint_reg;

2,929✔

5375

   else if (type_is_record(type)) {

1,213✔

5376

      if (type_const_bounds(type))

583✔

5377

         return emit_address_of(lower_nested_default_value(lu, type));

392✔

5379

      type_t base = type_base_recur(type);

191✔

5380

      const int nfields = type_fields(base);

191✔

5381

      vcode_type_t vtype = lower_type(type);

191✔

5383

      vcode_reg_t mem_reg = hint_reg;

191✔

5384

      if (hint_reg == VCODE_INVALID_REG) {

191✔

5385

         vcode_var_t tmp_var = lower_temp_var(lu, "def", vtype, vtype);

33✔

5386

         mem_reg = emit_index(tmp_var, VCODE_INVALID_REG);

33✔

5389

      for (int i = 0; i < nfields; i++) {

572✔

5390

         tree_t f = type_field(base, i);

381✔

5391

         vcode_reg_t ptr_reg = emit_record_ref(mem_reg, i);

381✔

5393

         type_t ftype = tree_type(f);

381✔

5394

         if (base != type && type_is_unconstrained(ftype)) {

381✔

5395

            tree_t ec = type_constraint_for_field(type, f);

175✔

5396

            assert(ec != NULL);

175✔

5397

            ftype = tree_type(ec);

175✔

5400

         if (type_is_scalar(ftype)) {

381✔

5401

            vcode_reg_t def_reg = lower_default_value(lu, ftype, ptr_reg);

106✔

5402

            emit_store_indirect(def_reg, ptr_reg);

106✔

5404

         else if (type_is_array(ftype)) {

275✔

5405

            if (have_uarray_ptr(ptr_reg)) {

257✔

5407

               type_t elem_type = type_elem_recur(ftype);

254✔

5408

               vcode_type_t vtype = lower_type(elem_type);

254✔

5409

               vcode_type_t vbounds = lower_bounds(elem_type);

254✔

5411

               vcode_reg_t count_reg =

254✔

5412

                  lower_array_total_len(lu, ftype, VCODE_INVALID_REG);

254✔

5413

               vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, count_reg);

254✔

5414

               vcode_reg_t def_reg = lower_default_value(lu, ftype, mem_reg);

254✔

5415

               assert(def_reg == mem_reg);

254✔

5417

               vcode_reg_t wrap_reg =

254✔

5418

                  lower_wrap_with_new_bounds(lu, ftype, tree_type(f),

254✔

5420

               emit_store_indirect(wrap_reg, ptr_reg);

254✔

5423

               vcode_reg_t def_reg = lower_default_value(lu, ftype, ptr_reg);

3✔

5424

               vcode_reg_t count_reg =

3✔

5425

                  lower_array_total_len(lu, ftype, VCODE_INVALID_REG);

3✔

5426

               emit_copy(ptr_reg, def_reg, count_reg);

3✔

5429

         else if (type_is_record(ftype)) {

18✔

5430

            vcode_reg_t def_reg =

15✔

5431

               lower_default_value(lu, ftype, VCODE_INVALID_REG);

15✔

5433

            emit_copy(ptr_reg, def_reg, VCODE_INVALID_REG);

15✔

5436

            vcode_reg_t def_reg = lower_default_value(lu, ftype, ptr_reg);

3✔

5437

            emit_store_indirect(def_reg, ptr_reg);

3✔

5443

   else if (type_is_access(type))

630✔

5444

      return emit_null(lower_type(type));

630✔

5450

static void lower_report(lower_unit_t *lu, tree_t stmt)

1,989✔

5452

   lower_stmt_coverage(lu, stmt);

1,989✔

5454

   vcode_reg_t severity_reg = VCODE_INVALID_REG;

1,989✔

5455

   if (tree_has_severity(stmt))

1,989✔

5456

      severity_reg = lower_rvalue(lu, tree_severity(stmt));

405✔

5458

      vcode_type_t vseverity = vtype_int(0, 3);

1,584✔

5459

      severity_reg = emit_const(vseverity, SEVERITY_NOTE);

1,584✔

5462

   vcode_reg_t message = VCODE_INVALID_REG, length = VCODE_INVALID_REG;

1,989✔

5463

   if (tree_has_message(stmt)) {

1,989✔

5464

      tree_t m = tree_message(stmt);

1,989✔

5466

      vcode_reg_t message_wrapped = lower_rvalue(lu, m);

1,989✔

5467

      message = lower_array_data(message_wrapped);

1,989✔

5468

      length  = lower_array_len(lu, tree_type(m), 0, message_wrapped);

1,989✔

5471

   vcode_reg_t locus = lower_debug_locus(stmt);

1,989✔

5472

   emit_report(message, length, severity_reg, locus);

1,989✔

5473

1,989✔

5475

static bool lower_can_hint_assert(tree_t expr)

10,342✔

5477

   if (tree_kind(expr) != T_FCALL)

10,342✔

5480

   switch (tree_subkind(tree_ref(expr))) {

9,789✔

5488

   default:

3,903✔

5489

      return false;

3,903✔

5493

static void lower_assert(lower_unit_t *lu, tree_t stmt)

14,028✔

5495

   lower_stmt_coverage(lu, stmt);

14,028✔

5497

   tree_t value = tree_value(stmt);

14,028✔

5499

   vcode_reg_t value_reg,

14,028✔

5500

      hint_left_reg = VCODE_INVALID_REG,

14,028✔

5501

      hint_right_reg = VCODE_INVALID_REG;

14,028✔

5503

   if (!tree_has_message(stmt) && lower_can_hint_assert(value))

14,028✔

5504

      value_reg = lower_builtin(lu, value, tree_subkind(tree_ref(value)),

5,886✔

5507

      value_reg = lower_rvalue(lu, value);

8,142✔

5509

   int64_t value_const;

14,028✔

5510

   if (vcode_reg_const(value_reg, &value_const) && value_const)

14,028✔

5511

      return;

150✔

5513

   vcode_block_t fail_bb = VCODE_INVALID_BLOCK;

13,878✔

5514

   vcode_block_t exit_bb = VCODE_INVALID_BLOCK;

13,878✔

5516

   tree_t message = tree_has_message(stmt) ? tree_message(stmt) : NULL;

13,878✔

5517

   tree_t severity = tree_has_severity(stmt) ? tree_severity(stmt) : NULL;

13,878✔

5521

   const bool has_side_effects =

27,756✔

5522

      (message != NULL && !lower_side_effect_free(message))

3,682✔

5523

      || (severity != NULL && !lower_side_effect_free(severity));

16,955✔

5525

   if (has_side_effects) {

13,878✔

5526

      fail_bb = emit_block();

636✔

5527

      exit_bb = emit_block();

636✔

5528

      emit_cond(value_reg, exit_bb, fail_bb);

636✔

5529

      vcode_select_block(fail_bb);

636✔

5532

   vcode_reg_t message_reg = VCODE_INVALID_REG, length_reg = VCODE_INVALID_REG;

13,878✔

5533

   if (message != NULL) {

13,878✔

5534

      vcode_reg_t message_wrapped = lower_rvalue(lu, message);

3,682✔

5535

      message_reg = lower_array_data(message_wrapped);

3,682✔

5536

      length_reg  = lower_array_len(lu, tree_type(message), 0, message_wrapped);

3,682✔

5539

   vcode_reg_t severity_reg = VCODE_INVALID_REG;

13,878✔

5540

   if (severity != NULL)

13,878✔

5541

      severity_reg = lower_rvalue(lu, severity);

3,387✔

5543

      vcode_type_t vseverity = vtype_int(0, 3);

10,491✔

5544

      severity_reg = emit_const(vseverity, SEVERITY_ERROR);

10,491✔

5547

   vcode_reg_t locus = lower_debug_locus(value);

13,878✔

5548

   emit_assert(value_reg, message_reg, length_reg, severity_reg, locus,

13,878✔

5551

   if (exit_bb != VCODE_INVALID_BLOCK) {

13,878✔

5552

      emit_jump(exit_bb);

636✔

5553

      vcode_select_block(exit_bb);

636✔

5557

static void lower_sched_event_field_cb(lower_unit_t *lu, tree_t field,

1,560✔

5561

   type_t type = tree_type(field);

1,560✔

5562

   if (!type_is_homogeneous(type))

1,560✔

5563

      lower_for_each_field(lu, type, ptr, locus,

12✔

5566

      vcode_reg_t nets_reg = emit_load_indirect(ptr);

1,548✔

5567

      vcode_reg_t data_reg = lower_array_data(nets_reg);

1,548✔

5568

      vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

1,548✔

5570

      const bool clear = (uintptr_t)ctx;

1,548✔

5571

      if (clear)

1,548✔

5572

         emit_clear_event(data_reg, count_reg);

13✔

5574

         emit_sched_event(data_reg, count_reg);

1,535✔

5576

1,560✔

5578

static void lower_sched_event(lower_unit_t *lu, tree_t on)

4,463✔

5580

   type_t type = tree_type(on);

4,463✔

5582

   vcode_reg_t nets_reg = lower_lvalue(lu, on);

4,463✔

5583

   assert(nets_reg != VCODE_INVALID_REG);

4,463✔

5585

   if (!type_is_homogeneous(type))

4,463✔

5586

      lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG,

584✔

5589

      vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

3,879✔

5590

      vcode_reg_t data_reg = lower_array_data(nets_reg);

3,879✔

5591

      emit_sched_event(data_reg, count_reg);

3,879✔

5593

4,463✔

5595

static void lower_clear_event(lower_unit_t *lu, tree_t on)

498✔

5597

   type_t type = tree_type(on);

498✔

5599

   vcode_reg_t nets_reg = lower_lvalue(lu, on);

498✔

5600

   assert(nets_reg != VCODE_INVALID_REG);

498✔

5602

   if (!type_is_homogeneous(type))

498✔

5603

      lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG,

4✔

5606

      vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

494✔

5607

      vcode_reg_t data_reg = lower_array_data(nets_reg);

494✔

5608

      emit_clear_event(data_reg, count_reg);

494✔

5610

498✔

5612

static vcode_reg_t lower_call_now(void)

24✔

5614

   ident_t func = ident_new("STD.STANDARD.NOW()25STD.STANDARD.DELAY_LENGTH");

24✔

5615

   vcode_type_t rtype = vtype_time();

24✔

5616

   vcode_reg_t context_reg = emit_link_package(well_known(W_STD_STANDARD));

24✔

5617

   vcode_reg_t args[1] = { context_reg };

24✔

5618

   return emit_fcall(func, rtype, rtype, args, ARRAY_LEN(args));

24✔

5621

static void lower_wait(lower_unit_t *lu, tree_t wait)

12,914✔

5623

   const bool is_static = !!(tree_flags(wait) & TREE_F_STATIC_WAIT);

12,914✔

5624

   assert(!is_static || (!tree_has_delay(wait) && !tree_has_value(wait)));

12,914✔

5626

   const int ntriggers = tree_triggers(wait);

12,914✔

5628

   if (!is_static) {

12,914✔

5629

      lower_stmt_coverage(lu, wait);

9,149✔

5632

      for (int i = 0; i < ntriggers; i++)

9,647✔

5633

         lower_sched_event(lu, tree_trigger(wait, i));

498✔

5636

   const bool has_delay = tree_has_delay(wait);

12,914✔

5637

   const bool has_value = tree_has_value(wait);

12,914✔

5639

   vcode_reg_t delay = VCODE_INVALID_REG;

12,914✔

5640

   if (has_delay)

12,914✔

5641

      delay = lower_rvalue(lu, tree_delay(wait));

4,957✔

5643

   vcode_var_t remain = VCODE_INVALID_VAR;

12,914✔

5644

   if (has_value && has_delay) {

12,914✔

5645

      ident_t remain_i = ident_new("wait_remain");

12✔

5646

      remain = vcode_find_var(remain_i);

12✔

5647

      if (remain == VCODE_INVALID_VAR) {

12✔

5648

         vcode_type_t time = vtype_time();

12✔

5649

         remain = emit_var(time, time, remain_i, 0);

12✔

5652

      vcode_reg_t now_reg = lower_call_now();

12✔

5653

      vcode_reg_t abs_reg = emit_add(now_reg, delay);

12✔

5654

      emit_store(abs_reg, remain);

12✔

5657

   vcode_block_t resume = emit_block();

12,914✔

5658

   emit_wait(resume, delay);

12,914✔

5660

   vcode_select_block(resume);

12,914✔

5662

   if (!is_static) {

12,914✔

5663

      for (int i = 0; i < ntriggers; i++)

9,647✔

5664

         lower_clear_event(lu, tree_trigger(wait, i));

498✔

5667

   if (has_value) {

12,914✔

5670

      vcode_reg_t until_reg = lower_rvalue(lu, tree_value(wait));

277✔

5672

      vcode_reg_t timeout_reg = VCODE_INVALID_REG;

277✔

5673

      vcode_reg_t done_reg = until_reg;

277✔

5674

      if (has_delay) {

277✔

5675

         vcode_reg_t remain_reg = emit_load(remain);

12✔

5676

         vcode_reg_t now_reg = lower_call_now();

12✔

5677

         timeout_reg = emit_sub(remain_reg, now_reg);

12✔

5679

         vcode_reg_t expired_reg = emit_cmp(VCODE_CMP_EQ, timeout_reg,

12✔

5681

         done_reg = emit_or(expired_reg, until_reg);

12✔

5684

      vcode_block_t done_bb  = emit_block();

277✔

5685

      vcode_block_t again_bb = emit_block();

277✔

5687

      emit_cond(done_reg, done_bb, again_bb);

277✔

5689

      vcode_select_block(again_bb);

277✔

5691

      for (int i = 0; i < ntriggers; i++)

560✔

5692

         lower_sched_event(lu, tree_trigger(wait, i));

283✔

5694

      emit_wait(resume, timeout_reg);

277✔

5696

      vcode_select_block(done_bb);

277✔

5698

12,914✔

5700

static void lower_check_array_sizes(lower_unit_t *lu, type_t ltype,

20,951✔

5704

   const int ndims = dimension_of(ltype);

20,951✔

5705

   for (int i = 0; i < ndims; i++) {

42,861✔

5706

      vcode_reg_t llen_reg = lower_array_len(lu, ltype, i, lval);

21,910✔

5707

      vcode_reg_t rlen_reg = lower_array_len(lu, rtype, i, rval);

21,910✔

5709

      vcode_reg_t dim_reg = VCODE_INVALID_REG;

21,910✔

5710

      if (ndims > 1)

21,910✔

5711

         dim_reg = emit_const(vtype_offset(), i + 1);

1,769✔

5713

      emit_length_check(llen_reg, rlen_reg, locus, dim_reg);

21,910✔

5715

20,951✔

5717

static void lower_find_matching_refs(tree_t ref, void *context)

1,879✔

5719

   tree_t *decl = (tree_t *)context;

1,879✔

5720

   if (tree_ref(ref) == *decl)

1,879✔

5721

      *decl = NULL;

21✔

5722

1,879✔

5724

static bool lower_can_hint_aggregate(tree_t target, tree_t value)

13,656✔

5726

   if (tree_kind(value) != T_AGGREGATE)

13,656✔

5729

   type_t type = tree_type(target);

1,431✔

5730

   if (!type_const_bounds(type))

1,431✔

5733

   tree_t ref = name_to_ref(target);

833✔

5734

   if (ref == NULL)

833✔

5737

   tree_t decl = tree_ref(ref);

833✔

5738

   tree_visit_only(value, lower_find_matching_refs, &decl, T_REF);

833✔

5739

   return decl != NULL;

833✔

5742

static bool lower_can_hint_concat(tree_t target, tree_t value)

13,111✔

5744

   if (tree_kind(value) != T_FCALL)

13,111✔

5747

   tree_t fdecl = tree_ref(value);

3,538✔

5748

   if (tree_subkind(fdecl) != S_CONCAT)

3,538✔

5751

   if (!type_const_bounds(tree_type(target)))

140✔

5754

   tree_t ref = name_to_ref(target);

93✔

5755

   if (ref == NULL)

93✔

5758

   tree_t decl = tree_ref(ref);

93✔

5759

   tree_visit_only(value, lower_find_matching_refs, &decl, T_REF);

93✔

5760

   return decl != NULL;

93✔

5763

static int lower_count_target_parts(tree_t target, int depth)

8,643✔

5765

   if (tree_kind(target) == T_AGGREGATE) {

8,643✔

5766

      int count = 0;

132✔

5767

      const int nassocs = tree_assocs(target);

132✔

5768

      for (int i = 0; i < nassocs; i++) {

456✔

5769

         tree_t value = tree_value(tree_assoc(target, i));

324✔

5770

         count += lower_count_target_parts(value, depth + 1);

324✔

5773

      return count + (depth > 0 ? 2 : 1);

246✔

5776

      return depth == 0 ? 2 : 1;

8,511✔

5779

static void lower_fill_target_parts(lower_unit_t *lu, tree_t target,

8,643✔

5782

   type_t target_type = tree_type(target);

8,643✔

5784

   if (tree_kind(target) == T_AGGREGATE) {

8,643✔

5785

      const bool is_record = type_is_record(target_type);

132✔

5786

      const int ndims = dimension_of(target_type);

132✔

5788

      if (kind != PART_ALL) {

132✔

5789

         (*ptr)->reg    = VCODE_INVALID_REG;

18✔

5790

         (*ptr)->off    = VCODE_INVALID_REG;

18✔

5791

         (*ptr)->target = NULL;

18✔

5792

         (*ptr)->kind   = kind == PART_FIELD ? PART_PUSH_FIELD : PART_PUSH_ELEM;

18✔

5793

         ++(*ptr);

18✔

5796

      vcode_reg_t sum_reg = emit_const(vtype_offset(), 0);

132✔

5798

      const int nassocs = tree_assocs(target);

132✔

5799

      for (int i = 0; i < nassocs; i++) {

456✔

5800

         tree_t value = tree_value(tree_assoc(target, i));

324✔

5802

         part_kind_t newkind;

324✔

5803

         if (is_record)

324✔

5805

         else if (ndims == 1 && type_eq(tree_type(value), target_type))

231✔

5810

         lower_fill_target_parts(lu, value, newkind, ptr);

324✔

5812

         vcode_reg_t len_reg;

324✔

5813

         if (newkind == PART_SLICE)

324✔

5814

            len_reg = (*ptr - 1)->off;

42✔

5816

            len_reg = emit_const(vtype_offset(), 1);

282✔

5818

         sum_reg = emit_add(sum_reg, len_reg);

324✔

5821

      (*ptr)->reg    = VCODE_INVALID_REG;

132✔

5822

      (*ptr)->off    = sum_reg;

132✔

5823

      (*ptr)->target = NULL;

132✔

5824

      (*ptr)->kind   = PART_POP;

132✔

5825

      ++(*ptr);

132✔

5828

      (*ptr)->reg    = lower_lvalue(lu, target);

8,511✔

5829

      (*ptr)->target = target;

8,511✔

5830

      (*ptr)->kind   = kind;

8,511✔

5832

      if (type_is_array(target_type))

8,511✔

5833

         (*ptr)->off = lower_array_total_len(lu, target_type, (*ptr)->reg);

1,924✔

5835

         (*ptr)->off = emit_const(vtype_offset(), 1);

6,587✔

5837

      ++(*ptr);

8,511✔

5839

      if (kind == PART_ALL) {

8,511✔

5840

         (*ptr)->reg    = VCODE_INVALID_REG;

8,205✔

5841

         (*ptr)->off    = (*ptr - 1)->off;

8,205✔

5842

         (*ptr)->target = NULL;

8,205✔

5843

         (*ptr)->kind   = PART_POP;

8,205✔

5844

         ++(*ptr);

8,205✔

5847

8,643✔

5849

static void lower_copy_record(lower_unit_t *lu, type_t type,

433✔

5853

   if (dst_ptr == src_ptr)

433✔

5855

   else if (lower_trivially_copyable(type))

340✔

5856

      emit_copy(dst_ptr, src_ptr, VCODE_INVALID_REG);

285✔

5858

      ident_t base_id = type_ident(type_base_recur(type));

55✔

5859

      ident_t helper_func = ident_prefix(base_id, ident_new("copy"), '$');

55✔

5861

      vcode_reg_t args[] = {

55✔

5862

         lower_context_for_call(lu, helper_func),

55✔

5867

      emit_fcall(helper_func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

55✔

5872

static void lower_copy_array(lower_unit_t *lu, type_t dst_type, type_t src_type,

5,039✔

5876

   if (dst_array == src_array)

5,039✔

5878

   else if (lower_trivially_copyable(dst_type)) {

4,956✔

5879

      lower_check_array_sizes(lu, dst_type, src_type, dst_array,

4,947✔

5882

      vcode_reg_t count_reg = lower_array_total_len(lu, dst_type, dst_array);

4,947✔

5884

      vcode_reg_t src_data = lower_array_data(src_array);

4,947✔

5885

      vcode_reg_t dst_data = lower_array_data(dst_array);

4,947✔

5886

      emit_copy(dst_data, src_data, count_reg);

4,947✔

5889

      ident_t base_id = type_ident(type_base_recur(dst_type));

9✔

5890

      ident_t helper_func = ident_prefix(base_id, ident_new("copy"), '$');

9✔

5892

      assert(vcode_reg_kind(dst_array) == VCODE_TYPE_UARRAY);

9✔

5893

      assert(vcode_reg_kind(src_array) == VCODE_TYPE_UARRAY);

9✔

5895

      vcode_reg_t args[] = {

9✔

5896

         lower_context_for_call(lu, helper_func),

9✔

5901

      emit_fcall(helper_func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

9✔

5906

static void lower_var_assign_target(lower_unit_t *lu, target_part_t **ptr,

63✔

5910

   int fieldno = 0;

63✔

5911

   for (const target_part_t *p = (*ptr)++; p->kind != PART_POP; p = (*ptr)++) {

210✔

5912

      vcode_reg_t src_reg = rhs;

147✔

5913

      type_t src_type = rhs_type;

147✔

5914

      if (p->kind == PART_FIELD || p->kind == PART_PUSH_FIELD) {

147✔

5915

         assert(vcode_reg_kind(rhs) == VCODE_TYPE_POINTER);

39✔

5916

         src_reg = emit_record_ref(rhs, fieldno);

39✔

5917

         src_type = tree_type(type_field(src_type, fieldno));

39✔

5918

         fieldno++;

39✔

5921

      if (p->kind == PART_PUSH_FIELD || p->kind == PART_PUSH_ELEM) {

147✔

5922

         lower_var_assign_target(lu, ptr, where, src_reg, src_type);

9✔

5923

         continue;

9✔

5925

      else if (p->reg == VCODE_INVALID_REG)

138✔

5928

      if (p->kind == PART_ELEM)

138✔

5929

         src_type = type_elem(src_type);

84✔

5931

      type_t type = tree_type(p->target);

138✔

5933

      if (p->kind != PART_SLICE && type_is_array(type)) {

138✔

5934

         vcode_reg_t locus = lower_debug_locus(p->target);

15✔

5935

         lower_check_array_sizes(lu, type, src_type, p->reg, src_reg, locus);

15✔

5938

      if (p->kind == PART_ELEM || p->kind == PART_SLICE)

138✔

5939

         src_reg = lower_array_data(src_reg);

105✔

5941

      vcode_reg_t scalar_reg = src_reg;

138✔

5942

      if ((p->kind == PART_ELEM || p->kind == PART_FIELD)

138✔

5943

          && !type_is_composite(type))

117✔

5944

         scalar_reg = emit_load_indirect(src_reg);

102✔

5946

      if (type_is_scalar(type)) {

138✔

5947

         lower_check_scalar_bounds(lu, scalar_reg, type, where, p->target);

96✔

5948

         emit_store_indirect(scalar_reg, p->reg);

96✔

5950

      else if (type_is_array(type)) {

42✔

5951

         vcode_reg_t data_reg = lower_array_data(src_reg);

36✔

5952

         vcode_reg_t count_reg = lower_array_total_len(lu, type, p->reg);

36✔

5953

         vcode_reg_t dest_reg = lower_array_data(p->reg);

36✔

5955

         emit_copy(dest_reg, data_reg, count_reg);

36✔

5957

      else if (type_is_record(type)) {

6✔

5962

         emit_store_indirect(scalar_reg, p->reg);

6✔

5964

      if (p->kind == PART_ELEM || p->kind == PART_SLICE) {

138✔

5965

         assert(vcode_reg_kind(src_reg) == VCODE_TYPE_POINTER);

105✔

5966

         rhs = emit_array_ref(src_reg, p->off);

105✔

5969

63✔

5971

static void lower_var_assign(lower_unit_t *lu, tree_t stmt)

12,841✔

5973

   tree_t value  = tree_value(stmt);

12,841✔

5974

   tree_t target = tree_target(stmt);

12,841✔

5975

   type_t type   = tree_type(target);

12,841✔

5977

   lower_stmt_coverage(lu, stmt);

12,841✔

5979

   const bool is_var_decl =

25,682✔

5980

      tree_kind(target) == T_REF && tree_kind(tree_ref(target)) == T_VAR_DECL;

12,841✔

5981

   const bool is_scalar = type_is_scalar(type);

12,841✔

5982

   const bool is_access = type_is_access(type);

12,841✔

5984

   if (is_scalar || is_access) {

12,841✔

5985

      vcode_reg_t value_reg = lower_rvalue(lu, value);

7,484✔

5986

      vcode_var_t var = VCODE_INVALID_VAR;

7,484✔

5987

      int hops = 0;

7,484✔

5988

      if (is_scalar)

7,484✔

5989

         lower_check_scalar_bounds(lu, value_reg, type, value, target);

6,900✔

5991

         value_reg = lower_incomplete_access(value_reg, type_designated(type));

584✔

5993

      if (is_var_decl

7,484✔

5994

          && (var = lower_get_var(lu, tree_ref(target),

4,591✔

5996

          && hops == 0)

4,585✔

5997

         emit_store(value_reg, var);

4,402✔

5999

         vcode_reg_t ptr_reg = lower_lvalue(lu, target);

3,082✔

6000

         emit_store_indirect(value_reg, ptr_reg);

3,082✔

6003

   else if (tree_kind(target) == T_AGGREGATE) {

5,357✔

6004

      const int nparts = lower_count_target_parts(target, 0);

48✔

6005

      target_part_t *parts LOCAL = xmalloc_array(nparts, sizeof(target_part_t));

96✔

6007

      target_part_t *ptr = parts;

48✔

6008

      lower_fill_target_parts(lu, target, PART_ALL, &ptr);

48✔

6009

      assert(ptr == parts + nparts);

48✔

6011

      vcode_reg_t rhs = lower_rvalue(lu, value);

48✔

6013

      if (type_is_array(type)) {

48✔

6014

         vcode_reg_t rhs_len = lower_array_len(lu, tree_type(value), 0, rhs);

39✔

6015

         vcode_reg_t locus = lower_debug_locus(target);

39✔

6016

         assert(parts[nparts - 1].kind == PART_POP);

39✔

6017

         emit_length_check(parts[nparts - 1].off, rhs_len, locus,

39✔

6021

      ptr = parts;

48✔

6022

      lower_var_assign_target(lu, &ptr, value, rhs, tree_type(value));

48✔

6023

      assert(ptr == parts + nparts);

48✔

6025

   else if (type_is_array(type)) {

5,309✔

6026

      vcode_reg_t target_reg = lower_lvalue(lu, target);

4,993✔

6028

      vcode_reg_t value_reg;

4,993✔

6029

      if (lower_can_hint_aggregate(target, value))

4,993✔

6030

         value_reg = lower_aggregate(lu, value, lower_array_data(target_reg));

273✔

6031

      else if (lower_can_hint_concat(target, value)) {

4,720✔

6032

         vcode_reg_t hint_reg = lower_array_data(target_reg);

37✔

6033

         vcode_reg_t count_reg = lower_array_total_len(lu, type, target_reg);

37✔

6034

         value_reg = lower_concat(lu, value, hint_reg, count_reg);

37✔

6037

         value_reg = lower_known_subtype(lu, value, type, target_reg);

4,683✔

6039

      vcode_reg_t locus = lower_debug_locus(target);

4,993✔

6041

      type_t value_type = tree_type(value);

4,993✔

6042

      lower_copy_array(lu, type, value_type, target_reg, value_reg, locus);

4,993✔

6045

      vcode_reg_t target_reg = lower_lvalue(lu, target);

316✔

6047

      vcode_reg_t value_reg;

316✔

6048

      if (lower_can_hint_aggregate(target, value))

316✔

6049

         value_reg = lower_aggregate(lu, value, target_reg);

34✔

6051

         value_reg = lower_known_subtype(lu, value, type, target_reg);

282✔

6053

      vcode_reg_t locus = lower_debug_locus(stmt);

316✔

6054

      lower_copy_record(lu, type, target_reg, value_reg, locus);

316✔

6056

12,841✔

6058

static void lower_signal_target_field_cb(lower_unit_t *lu, tree_t field,

2,806✔

6063

   type_t type = tree_type(field);

2,806✔

6064

   vcode_reg_t *args = __ctx;

2,806✔

6066

   if (!type_is_homogeneous(type))

2,806✔

6067

      lower_for_each_field_2(lu, type, type, dst_ptr, src_ptr, locus,

89✔

6069

   else if (type_is_array(type)) {

2,717✔

6070

      vcode_reg_t src_array = VCODE_INVALID_REG;

702✔

6071

      vcode_reg_t dst_array = VCODE_INVALID_REG;

702✔

6073

      vcode_reg_t nets_reg;

702✔

6074

      if (have_uarray_ptr(dst_ptr)) {

702✔

6075

         dst_array = emit_load_indirect(dst_ptr);

102✔

6076

         nets_reg  = lower_array_data(dst_array);

102✔

6079

         nets_reg = emit_load_indirect(dst_ptr);

600✔

6081

      vcode_reg_t array_reg;

702✔

6082

      if (have_uarray_ptr(src_ptr)) {

702✔

6083

         src_array = emit_load_indirect(src_ptr);

102✔

6084

         array_reg = lower_resolved(lu, type, src_array);

102✔

6087

         array_reg = lower_resolved(lu, type, src_ptr);

600✔

6089

      lower_check_array_sizes(lu, type, type, dst_array, src_array, locus);

702✔

6091

      vcode_reg_t count_reg = lower_array_total_len(lu, type, array_reg);

702✔

6092

      vcode_reg_t data_reg  = lower_array_data(array_reg);

702✔

6093

      emit_sched_waveform(nets_reg, count_reg, data_reg,

702✔

6097

      vcode_reg_t nets_reg = emit_load_indirect(dst_ptr);

2,015✔

6098

      vcode_reg_t data_reg = lower_resolved(lu, type, src_ptr);

2,015✔

6099

      emit_sched_waveform(nets_reg, emit_const(vtype_offset(), 1),

2,015✔

6102

2,806✔

6104

static void lower_signal_assign_target(lower_unit_t *lu, target_part_t **ptr,

8,572✔

6109

   int fieldno = 0;

8,572✔

6110

   for (const target_part_t *p = (*ptr)++; p->kind != PART_POP; p = (*ptr)++) {

17,252✔

6111

      vcode_reg_t src_reg = rhs;

8,680✔

6112

      type_t src_type = rhs_type;

8,680✔

6113

      if (p->kind == PART_FIELD || p->kind == PART_PUSH_FIELD) {

8,680✔

6114

         assert(vcode_reg_kind(rhs) == VCODE_TYPE_POINTER);

54✔

6115

         src_reg = emit_record_ref(rhs, fieldno);

54✔

6116

         src_type = tree_type(type_field(src_type, fieldno));

54✔

6117

         fieldno++;

54✔

6120

      if (p->kind == PART_PUSH_FIELD || p->kind == PART_PUSH_ELEM) {

8,680✔

6121

         lower_signal_assign_target(lu, ptr, where, src_reg, src_type,

9✔

6123

         continue;

9✔

6125

      else if (p->reg == VCODE_INVALID_REG)

8,671✔

6128

      if (p->kind == PART_ELEM)

8,671✔

6129

         src_type = type_elem(src_type);

99✔

6131

      type_t type = tree_type(p->target);

8,671✔

6133

      if (p->kind != PART_SLICE && type_is_array(type)) {

8,671✔

6134

         vcode_reg_t locus = lower_debug_locus(p->target);

1,943✔

6135

         lower_check_array_sizes(lu, type, src_type, p->reg, src_reg, locus);

1,943✔

6138

      if (p->kind == PART_ELEM || p->kind == PART_SLICE)

8,671✔

6139

         src_reg = lower_array_data(src_reg);

120✔

6141

      if (type_is_scalar(type))

8,671✔

6142

         lower_check_scalar_bounds(lu, src_reg, type, where, p->target);

6,057✔

6144

      if (!type_is_homogeneous(type)) {

8,671✔

6145

         vcode_reg_t args[2] = { reject, after };

790✔

6146

         vcode_reg_t locus = lower_debug_locus(where);

790✔

6147

         lower_for_each_field_2(lu, type, src_type, p->reg, src_reg, locus,

790✔

6150

      else if (type_is_array(type)) {

7,881✔

6151

         vcode_reg_t resolved_reg = lower_resolved(lu, type, src_reg);

1,824✔

6152

         vcode_reg_t data_reg = lower_array_data(resolved_reg);

1,824✔

6153

         vcode_reg_t count_reg = lower_array_total_len(lu, type, p->reg);

1,824✔

6154

         vcode_reg_t nets_raw = lower_array_data(p->reg);

1,824✔

6156

         emit_sched_waveform(nets_raw, count_reg, data_reg, reject, after);

1,824✔

6159

         vcode_reg_t data_reg = lower_resolved(lu, type, src_reg);

6,057✔

6160

         emit_sched_waveform(p->reg, emit_const(vtype_offset(), 1),

6,057✔

6164

      if (p->kind == PART_ELEM || p->kind == PART_SLICE) {

8,671✔

6165

         assert(vcode_reg_kind(src_reg) == VCODE_TYPE_POINTER);

120✔

6166

         rhs = emit_array_ref(src_reg, p->off);

120✔

6169

8,572✔

6171

static void lower_disconnect_target(lower_unit_t *lu, target_part_t **ptr,

24✔

6174

   for (const target_part_t *p = (*ptr)++; p->kind != PART_POP; p = (*ptr)++) {

48✔

6175

      if (p->kind == PART_PUSH_FIELD || p->kind == PART_PUSH_ELEM) {

24✔

6179

      else if (p->reg == VCODE_INVALID_REG)

24✔

6182

      vcode_reg_t nets_reg = lower_array_data(p->reg);

24✔

6184

      type_t type = tree_type(p->target);

24✔

6186

      if (type_is_record(type)) {

24✔

6193

         vcode_reg_t count_reg = lower_type_width(lu, type, p->reg);

24✔

6194

         emit_disconnect(nets_reg, count_reg, reject, after);

24✔

6197

24✔

6199

static void lower_signal_assign(lower_unit_t *lu, tree_t stmt)

8,265✔

6201

   lower_stmt_coverage(lu, stmt);

8,265✔

6203

   tree_t target = tree_target(stmt);

8,265✔

6205

   const int nparts = lower_count_target_parts(target, 0);

8,265✔

6206

   target_part_t *parts LOCAL = xmalloc_array(nparts, sizeof(target_part_t));

16,530✔

6208

   target_part_t *ptr = parts;

8,265✔

6209

   lower_fill_target_parts(lu, target, PART_ALL, &ptr);

8,265✔

6210

   assert(ptr == parts + nparts);

8,265✔

6212

   const int nwaveforms = tree_waveforms(stmt);

8,265✔

6213

   for (int i = 0; i < nwaveforms; i++) {

16,740✔

6214

      tree_t w = tree_waveform(stmt, i);

8,475✔

6216

      tree_t delay = NULL;

8,475✔

6217

      vcode_reg_t delay_reg;

8,475✔

6218

      if (tree_has_delay(w)) {

8,475✔

6219

         delay = tree_delay(w);

720✔

6220

         delay_reg = lower_rvalue(lu, delay);

720✔

6223

         delay_reg = emit_const(vtype_time(), 0);

7,755✔

6225

      vcode_reg_t reject_reg;

8,475✔

6226

      if (i == 0 && tree_has_reject(stmt)) {

8,475✔

6227

         tree_t reject = tree_reject(stmt);

498✔

6228

         if (reject == delay) {

498✔

6234

            reject_reg = lower_rvalue(lu, reject);

27✔

6238

         reject_reg = emit_const(vtype_time(), 0);

7,977✔

6241

      vcode_var_t tmp_var = VCODE_INVALID_VAR;

8,475✔

6243

      target_part_t *ptr = parts;

8,475✔

6244

      if (tree_has_value(w)) {

8,475✔

6245

         tree_t wvalue = tree_value(w);

8,451✔

6246

         type_t wtype = tree_type(wvalue);

8,451✔

6247

         vcode_reg_t rhs = VCODE_INVALID_REG;

8,451✔

6248

         if (ptr->kind == PART_ALL) {

8,451✔

6249

            if (lower_can_hint_concat(ptr->target, wvalue)) {

8,391✔

6250

               type_t ptype = tree_type(ptr->target);

44✔

6252

               vcode_type_t vtype = lower_type(ptype);

44✔

6253

               vcode_type_t vbounds = lower_bounds(ptype);

44✔

6254

               tmp_var = lower_temp_var(lu, "tmp", vtype, vbounds);

44✔

6256

               vcode_reg_t count_reg =

44✔

6257

                  lower_array_total_len(lu, ptype, ptr->reg);

44✔

6258

               vcode_reg_t hint_reg = emit_index(tmp_var, VCODE_INVALID_REG);

44✔

6259

               rhs = lower_concat(lu, wvalue, hint_reg, count_reg);

44✔

6261

            else if (lower_can_hint_aggregate(ptr->target, wvalue)) {

8,347✔

6262

               type_t ptype = tree_type(ptr->target);

517✔

6264

               vcode_type_t vtype = lower_type(ptype);

517✔

6265

               vcode_type_t vbounds = lower_bounds(ptype);

517✔

6266

               tmp_var = lower_temp_var(lu, "tmp", vtype, vbounds);

517✔

6268

               vcode_reg_t hint_reg  = emit_index(tmp_var, VCODE_INVALID_REG);

517✔

6269

               rhs = lower_aggregate(lu, wvalue, hint_reg);

517✔

6271

            else if (type_is_record(wtype) && lower_is_signal_ref(wvalue)) {

7,830✔

6275

               rhs = lower_lvalue(lu, wvalue);

283✔

6277

            else if (standard() >= STD_19) {

7,547✔

6278

               type_t ptype = tree_type(ptr->target);

172✔

6279

               rhs = lower_known_subtype(lu, wvalue, ptype, ptr->reg);

172✔

6283

         if (rhs == VCODE_INVALID_REG)

1,016✔

6284

            rhs = lower_rvalue(lu, wvalue);

7,435✔

6286

         if (ptr->kind != PART_ALL && type_is_array(wtype)) {

8,451✔

6287

            vcode_reg_t rhs_len = lower_array_len(lu, wtype, 0, rhs);

45✔

6288

            vcode_reg_t locus = lower_debug_locus(target);

45✔

6289

            assert(parts[nparts - 1].kind == PART_POP);

45✔

6290

            emit_length_check(parts[nparts - 1].off, rhs_len, locus,

45✔

6294

         lower_signal_assign_target(lu, &ptr, wvalue, rhs, wtype,

8,451✔

6298

         lower_disconnect_target(lu, &ptr, reject_reg, delay_reg);

24✔

6299

      assert(ptr == parts + nparts);

8,475✔

6301

      if (tmp_var != VCODE_INVALID_VAR)

8,475✔

6302

         lower_release_temp(lu, tmp_var);

561✔

6304

8,265✔

6306

static void lower_force_field_cb(lower_unit_t *lu, tree_t field,

9✔

6310

   type_t type = tree_type(field);

9✔

6311

   if (type_is_homogeneous(type)) {

9✔

6312

      vcode_reg_t nets_reg = emit_load_indirect(ptr);

9✔

6313

      vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

9✔

6314

      emit_force(lower_array_data(nets_reg), count_reg, value);

9✔

6319

9✔

6321

static void lower_force(lower_unit_t *lu, tree_t stmt)

54✔

6323

   tree_t target = tree_target(stmt);

54✔

6324

   type_t type = tree_type(target);

54✔

6326

   vcode_reg_t nets = lower_lvalue(lu, target);

54✔

6328

   tree_t value = tree_value(stmt);

54✔

6329

   type_t value_type = tree_type(value);

54✔

6330

   vcode_reg_t value_reg = lower_rvalue(lu, value);

54✔

6332

   if (type_is_array(type)) {

54✔

6333

      vcode_reg_t locus = lower_debug_locus(target);

12✔

6334

      lower_check_array_sizes(lu, type, value_type, nets, value_reg, locus);

12✔

6336

      vcode_reg_t count_reg = lower_array_total_len(lu, type, nets);

12✔

6337

      vcode_reg_t data_reg = lower_array_data(value_reg);

12✔

6338

      emit_force(lower_array_data(nets), count_reg, data_reg);

12✔

6340

   else if (type_is_record(type)) {

42✔

6341

      vcode_reg_t locus = lower_debug_locus(value);

3✔

6342

      lower_for_each_field_2(lu, type, value_type, nets, value_reg, locus,

3✔

6346

      emit_force(nets, emit_const(vtype_offset(), 1), value_reg);

39✔

6347

54✔

6349

static void lower_release(lower_unit_t *lu, tree_t stmt)

30✔

6351

   tree_t target = tree_target(stmt);

30✔

6352

   type_t type = tree_type(target);

30✔

6354

   vcode_reg_t nets = lower_lvalue(lu, target);

30✔

6356

   if (type_is_array(type)) {

30✔

6357

      vcode_reg_t count_reg = lower_array_total_len(lu, type, nets);

6✔

6358

      emit_release(lower_array_data(nets), count_reg);

6✔

6360

   else if (type_is_record(type)) {

24✔

6364

      emit_release(nets, emit_const(vtype_offset(), 1));

24✔

6365

30✔

6367

static void lower_sequence(lower_unit_t *lu, tree_t block, loop_stack_t *loops)

28,625✔

6369

   const int nstmts = tree_stmts(block);

28,625✔

6370

   for (int i = 0; i < nstmts; i++)

103,733✔

6371

      lower_stmt(lu, tree_stmt(block, i), loops);

75,108✔

6372

28,625✔

6374

static void lower_if(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

5,604✔

6376

   lower_stmt_coverage(lu, stmt);

5,604✔

6378

   vcode_block_t exit_bb = VCODE_INVALID_BLOCK;

5,604✔

6379

   const bool want_coverage = cover_enabled(lu->cover, COVER_MASK_BRANCH);

5,604✔

6381

   const int nconds = tree_conds(stmt);

5,604✔

6382

   for (int i = 0; i < nconds; i++) {

11,942✔

6383

      tree_t c = tree_cond(stmt, i);

8,527✔

6384

      vcode_block_t next_bb = VCODE_INVALID_BLOCK;

8,527✔

6385

      PUSH_COVER_SCOPE(lu, c);

17,054✔

6387

      if (tree_has_value(c)) {

8,527✔

6388

         vcode_reg_t test = lower_rvalue(lu, tree_value(c));

6,338✔

6389

         vcode_block_t btrue = emit_block();

6,338✔

6391

         if (i == nconds - 1 && !want_coverage) {

6,338✔

6392

            if (exit_bb == VCODE_INVALID_BLOCK)

3,384✔

6393

               exit_bb = emit_block();

3,271✔

6397

            next_bb = emit_block();

2,954✔

6399

         emit_cond(test, btrue, next_bb);

6,338✔

6401

         if (want_coverage)

6,338✔

6402

            lower_branch_coverage(lu, c, btrue, next_bb);

181✔

6404

         vcode_select_block(btrue);

6,338✔

6407

      lower_sequence(lu, c, loops);

8,527✔

6409

      if (!vcode_block_finished()) {

8,527✔

6410

         if (exit_bb == VCODE_INVALID_BLOCK)

4,708✔

6411

            exit_bb = emit_block();

1,629✔

6412

         emit_jump(exit_bb);

4,708✔

6415

      if (next_bb == VCODE_INVALID_BLOCK)

8,527✔

6418

      vcode_select_block(next_bb);

6,338✔

6420

      if (i == nconds - 1 && want_coverage) {

6,338✔

6421

         if (exit_bb == VCODE_INVALID_BLOCK)

31✔

6422

            exit_bb = emit_block();

3✔

6423

         emit_jump(exit_bb);

31✔

6427

   if (exit_bb != VCODE_INVALID_BLOCK)

5,604✔

6428

      vcode_select_block(exit_bb);

4,903✔

6429

5,604✔

6431

static void lower_leave_subprogram(lower_unit_t *lu)

11,033✔

6435

   const int ndecls = tree_decls(lu->container);

11,033✔

6436

   for (int i = 0; i < ndecls; i++) {

28,666✔

6437

      tree_t d = tree_decl(lu->container, i);

17,633✔

6438

      switch (tree_kind(d)) {

17,633✔

6439

      case T_VAR_DECL:

11,377✔

6440

         if (type_is_protected(tree_type(d))) {

11,377✔

6441

            int hops = 0;

7✔

6442

            vcode_var_t var = lower_get_var(lu, d, &hops);

7✔

6443

            assert(var != VCODE_INVALID_VAR);

7✔

6445

            vcode_reg_t obj_reg;

7✔

6446

            if (hops == 0)

7✔

6447

               obj_reg = emit_load(var);

7✔

6451

            emit_protected_free(obj_reg);

7✔

6455

      case T_FILE_DECL:

20✔

6457

            type_t base = type_base_recur(tree_type(d));

20✔

6459

            LOCAL_TEXT_BUF tb = tb_new();

40✔

6460

            tb_istr(tb, ident_runtil(type_ident(base), '.'));

20✔

6461

            tb_cat(tb, ".FILE_CLOSE(");

20✔

6462

            mangle_one_type(tb, base);

20✔

6463

            tb_cat(tb, ")");

20✔

6464

            tb_cat(tb, "$predef");

20✔

6466

            ident_t func = ident_new(tb_get(tb));

20✔

6468

            vcode_reg_t ptr_reg = lower_var_ref(lu, d, EXPR_LVALUE);

20✔

6469

            vcode_reg_t context_reg = lower_context_for_call(lu, func);

20✔

6470

            vcode_reg_t args[] = { context_reg, ptr_reg };

20✔

6471

            emit_fcall(func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

20✔

6474

         break;

20✔

6480

11,033✔

6482

static void lower_return(lower_unit_t *lu, tree_t stmt)

9,538✔

6484

   lower_stmt_coverage(lu, stmt);

9,538✔

6486

   if (is_subprogram(lu->container))

9,538✔

6487

      lower_leave_subprogram(lu);

9,538✔

6489

   if (tree_has_value(stmt)) {

9,538✔

6490

      tree_t value = tree_value(stmt);

9,291✔

6491

      type_t type = tree_type(value);

9,291✔

6493

      vcode_reg_t value_reg = lower_rvalue(lu, value);

9,291✔

6495

      if (type_is_scalar(type)) {

9,291✔

6496

         lower_check_scalar_bounds(lu, value_reg, type, value, NULL);

4,871✔

6497

         emit_return(value_reg);

4,871✔

6499

      else if (type_is_access(type)) {

4,420✔

6500

         type_t access = type_designated(type);

92✔

6501

         emit_return(lower_incomplete_access(value_reg, access));

92✔

6503

      else if (type_is_array(type)) {

4,328✔

6504

         type_t rtype = type_result(tree_type(lu->container));

3,646✔

6505

         emit_return(lower_coerce_arrays(lu, type, rtype, value_reg));

3,646✔

6508

         emit_return(value_reg);

682✔

6511

      emit_return(VCODE_INVALID_REG);

247✔

6512

9,538✔

6514

static void lower_pcall(lower_unit_t *lu, tree_t pcall)

6,125✔

6516

   lower_stmt_coverage(lu, pcall);

6,125✔

6518

   tree_t decl = tree_ref(pcall);

6,125✔

6520

   const subprogram_kind_t kind = tree_subkind(decl);

6,125✔

6521

   if (is_open_coded_builtin(kind)) {

6,125✔

6522

      lower_builtin(lu, pcall, kind, NULL, NULL);

567✔

6523

      return;

567✔

6526

   bool use_fcall;

5,558✔

6527

   switch (vcode_unit_kind(lu->vunit)) {

5,558✔

6532

   case VCODE_UNIT_PROCESS:

4,127✔

6534

         tree_t wait = tree_stmt(lu->container, tree_stmts(lu->container) - 1);

4,127✔

6535

         if (tree_kind(wait) == T_WAIT

4,127✔

6536

             && (tree_flags(wait) & TREE_F_STATIC_WAIT)) {

3,926✔

6545

      use_fcall = !!(tree_flags(decl) & TREE_F_NEVER_WAITS);

4,234✔

6546

      break;

4,234✔

6549

   const int nparams = tree_params(pcall);

5,558✔

6550

   SCOPED_A(vcode_reg_t) args = AINIT;

11,116✔

6552

   ident_t name = tree_ident2(decl);

5,558✔

6554

   if (tree_kind(pcall) == T_PROT_PCALL && tree_has_name(pcall))

5,558✔

6555

      APUSH(args, lower_rvalue(lu, tree_name(pcall)));

180✔

6557

      APUSH(args, lower_context_for_call(lu, name));

5,378✔

6559

   const int arg0 = args.count;

5,558✔

6560

   for (int i = 0; i < nparams; i++) {

20,054✔

6561

      vcode_reg_t arg_reg = lower_subprogram_arg(lu, pcall, i);

14,496✔

6562

      if (!use_fcall)

14,496✔

6563

         vcode_heap_allocate(arg_reg);

1,361✔

6565

      APUSH(args, arg_reg);

14,496✔

6568

   if (use_fcall)

5,558✔

6569

      emit_fcall(name, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

4,675✔

6570

                 args.items, args.count);

4,675✔

6572

      vcode_block_t resume_bb = emit_block();

883✔

6574

      emit_pcall(name, args.items, args.count, resume_bb);

883✔

6575

      vcode_select_block(resume_bb);

883✔

6576

      emit_resume(name);

883✔

6580

   const int nports = tree_ports(decl);

5,558✔

6581

   for (int i = 0; i < nports; i++) {

20,054✔

6582

      tree_t p = tree_port(decl, i);

14,496✔

6583

      if (tree_class(p) != C_VARIABLE || tree_subkind(p) == PORT_IN)

14,496✔

6584

         continue;

14,490✔

6586

      tree_t value = tree_value(tree_param(pcall, i));

3,420✔

6587

      if (tree_kind(value) != T_AGGREGATE)

3,420✔

6588

         continue;

3,414✔

6590

      const int nparts = lower_count_target_parts(value, 0);

6✔

6591

      target_part_t *parts LOCAL = xmalloc_array(nparts, sizeof(target_part_t));

12✔

6593

      target_part_t *ptr = parts;

6✔

6594

      lower_fill_target_parts(lu, value, PART_ALL, &ptr);

6✔

6595

      assert(ptr == parts + nparts);

6✔

6597

      vcode_reg_t arg_reg = args.items[arg0 + i];

6✔

6599

      ptr = parts;

6✔

6600

      lower_var_assign_target(lu, &ptr, value, arg_reg, tree_type(value));

6✔

6601

      assert(ptr == parts + nparts);

6✔

6605

static void lower_wait_free_cb(tree_t t, void *ctx)

31,487✔

6607

   int *count = ctx;

31,487✔

6609

   const tree_kind_t kind = tree_kind(t);

31,487✔

6610

   if (kind == T_PCALL || kind == T_PROT_PCALL || kind == T_WAIT)

31,487✔

6611

      (*count)++;

265✔

6612

31,487✔

6614

static bool lower_is_wait_free(lower_unit_t *lu, tree_t stmt)

2,201✔

6616

   switch (vcode_unit_kind(lu->vunit)) {

2,201✔

6617

   case VCODE_UNIT_PROCEDURE:

831✔

6620

         int count = 0;

831✔

6621

         tree_visit(stmt, lower_wait_free_cb, &count);

831✔

6622

         return count == 0;

831✔

6629

static void lower_for(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

2,210✔

6631

   lower_stmt_coverage(lu, stmt);

2,210✔

6633

   tree_t r = tree_range(stmt, 0);

2,210✔

6634

   vcode_reg_t left_reg  = lower_range_left(lu, r);

2,210✔

6635

   vcode_reg_t right_reg = lower_range_right(lu, r);

2,210✔

6636

   vcode_reg_t dir_reg   = lower_range_dir(lu, r);

2,210✔

6637

   vcode_reg_t null_reg  = emit_range_null(left_reg, right_reg, dir_reg);

2,210✔

6639

   vcode_block_t exit_bb = VCODE_INVALID_BLOCK;

2,210✔

6641

   int64_t null_const;

2,210✔

6642

   if (vcode_reg_const(null_reg, &null_const) && null_const)

2,210✔

6643

      return;   // Loop range is always null

9✔

6645

      vcode_block_t init_bb = emit_block();

2,201✔

6646

      exit_bb = emit_block();

2,201✔

6647

      emit_cond(null_reg, exit_bb, init_bb);

2,201✔

6648

      vcode_select_block(init_bb);

2,201✔

6651

   tree_t idecl = tree_decl(stmt, 0);

2,201✔

6653

   vcode_type_t vtype  = lower_type(tree_type(idecl));

2,201✔

6654

   vcode_type_t bounds = vtype;

2,201✔

6656

   vcode_reg_t step_down = emit_const(vtype, -1);

2,201✔

6657

   vcode_reg_t step_up   = emit_const(vtype, 1);

2,201✔

6658

   vcode_reg_t step_reg  = emit_select(dir_reg, step_down, step_up);

2,201✔

6662

   const bool is_wait_free = lower_is_wait_free(lu, stmt);

2,201✔

6663

   vcode_var_t right_var = VCODE_INVALID_VAR, step_var = VCODE_INVALID_VAR;

2,201✔

6664

   if (!is_wait_free) {

2,201✔

6665

      right_var = lower_temp_var(lu, "right", vtype, vtype);

202✔

6666

      emit_store(right_reg, right_var);

202✔

6668

      step_var = lower_temp_var(lu, "step", vtype, vtype);

202✔

6669

      emit_store(step_reg, step_var);

202✔

6672

   int64_t lconst, rconst, dconst;

2,201✔

6673

   const bool l_is_const = vcode_reg_const(left_reg, &lconst);

2,201✔

6674

   const bool r_is_const = vcode_reg_const(right_reg, &rconst);

2,201✔

6675

   if (l_is_const && r_is_const)

2,201✔

6676

      bounds = vtype_int(MIN(lconst, rconst), MAX(lconst, rconst));

1,077✔

6677

   else if ((l_is_const || r_is_const) && vcode_reg_const(dir_reg, &dconst)) {

1,124✔

6678

      if (dconst == RANGE_TO)

350✔

6679

         bounds = vtype_int(l_is_const ? lconst : vtype_low(vtype),

630✔

6680

                            r_is_const ? rconst : vtype_high(vtype));

315✔

6682

         bounds = vtype_int(r_is_const ? rconst : vtype_low(vtype),

66✔

6683

                            l_is_const ? lconst : vtype_high(vtype));

31✔

6686

   ident_t ident = ident_prefix(tree_ident(idecl), tree_ident(stmt), '.');

2,201✔

6687

   vcode_var_t ivar = emit_var(vtype, bounds, ident, 0);

2,201✔

6689

   emit_store(left_reg, ivar);

2,201✔

6691

   vcode_block_t body_bb = emit_block();

2,201✔

6692

   emit_jump(body_bb);

2,201✔

6693

   vcode_select_block(body_bb);

2,201✔

6695

   vcode_reg_t ireg = VCODE_INVALID_VAR;

2,201✔

6696

   if (is_wait_free) {

2,201✔

6697

      ireg = emit_load(ivar);

1,999✔

6698

      lower_put_vcode_obj(idecl, ireg, lu);

1,999✔

6701

      lower_put_vcode_obj(idecl, ivar | PARAM_VAR_BIT, lu);

202✔

6703

   if (exit_bb == VCODE_INVALID_BLOCK)

2,201✔

6706

   loop_stack_t this = {

2,201✔

6708

      .name    = tree_ident(stmt),

2,201✔

6713

   lower_sequence(lu, stmt, &this);

2,201✔

6715

   if (this.test_bb != VCODE_INVALID_BLOCK) {

2,201✔

6717

      if (!vcode_block_finished())

17✔

6718

         emit_jump(this.test_bb);

16✔

6719

      vcode_select_block(this.test_bb);

17✔

6722

   vcode_reg_t rightn_reg = right_reg;

2,201✔

6723

   if (right_var != VCODE_INVALID_VAR)

2,201✔

6724

      rightn_reg = emit_load(right_var);

202✔

6726

   vcode_reg_t stepn_reg = step_reg;

2,201✔

6727

   if (step_var != VCODE_INVALID_VAR)

2,201✔

6728

      stepn_reg = emit_load(step_var);

202✔

6730

   if (ireg == VCODE_INVALID_REG)

2,201✔

6731

      ireg = emit_load(ivar);

202✔

6733

   if (!vcode_block_finished()) {

2,201✔

6734

      vcode_reg_t next_reg = emit_add(ireg, stepn_reg);

2,200✔

6735

      emit_store(next_reg, ivar);

2,200✔

6737

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, ireg, rightn_reg);

2,200✔

6738

      emit_cond(done_reg, exit_bb, body_bb);

2,200✔

6741

   vcode_select_block(exit_bb);

2,201✔

6743

   if (!is_wait_free) {

2,201✔

6744

      lower_release_temp(lu, right_var);

202✔

6745

      lower_release_temp(lu, step_var);

202✔

6749

static void lower_while(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

183✔

6751

   lower_stmt_coverage(lu, stmt);

183✔

6753

   vcode_block_t test_bb = emit_block();

183✔

6754

   vcode_block_t body_bb = emit_block();

183✔

6755

   vcode_block_t exit_bb = emit_block();

183✔

6757

   emit_jump(test_bb);

183✔

6759

   vcode_select_block(test_bb);

183✔

6761

   vcode_reg_t test = lower_rvalue(lu, tree_value(stmt));

183✔

6763

   emit_cond(test, body_bb, exit_bb);

183✔

6765

   if (cover_enabled(lu->cover, COVER_MASK_BRANCH))

183✔

6768

   vcode_select_block(body_bb);

183✔

6770

   loop_stack_t this = {

183✔

6772

      .name    = tree_ident(stmt),

183✔

6777

   lower_sequence(lu, stmt, &this);

183✔

6779

   if (!vcode_block_finished())

183✔

6780

      emit_jump(test_bb);

183✔

6782

   vcode_select_block(exit_bb);

183✔

6783

183✔

6785

static void lower_loop(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

101✔

6787

   lower_stmt_coverage(lu, stmt);

101✔

6789

   vcode_block_t body_bb = emit_block();

101✔

6790

   vcode_block_t exit_bb = emit_block();

101✔

6792

   emit_jump(body_bb);

101✔

6794

   vcode_select_block(body_bb);

101✔

6796

   loop_stack_t this = {

101✔

6798

      .name    = tree_ident(stmt),

101✔

6803

   lower_sequence(lu, stmt, &this);

101✔

6805

   if (!vcode_block_finished())

101✔

6806

      emit_jump(body_bb);

101✔

6808

   vcode_select_block(exit_bb);

101✔

6809

101✔

6811

static void lower_loop_control(lower_unit_t *lu, tree_t stmt,

279✔

6814

   lower_stmt_coverage(lu, stmt);

279✔

6816

   vcode_block_t false_bb = emit_block();

279✔

6818

   if (tree_has_value(stmt)) {

279✔

6819

      vcode_block_t true_bb = emit_block();

137✔

6820

      vcode_reg_t result = lower_rvalue(lu, tree_value(stmt));

137✔

6822

      emit_cond(result, true_bb, false_bb);

137✔

6824

      if (cover_enabled(lu->cover, COVER_MASK_BRANCH))

137✔

6827

      vcode_select_block(true_bb);

137✔

6830

   ident_t label = tree_ident2(stmt);

279✔

6831

   loop_stack_t *it;

279✔

6832

   for (it = loops; it != NULL && it->name != label; it = it->up)

567✔

6834

   assert(it != NULL);

279✔

6836

   if (tree_kind(stmt) == T_EXIT)

279✔

6837

      emit_jump(it->exit_bb);

241✔

6839

      if (it->test_bb == VCODE_INVALID_BLOCK)

38✔

6840

         it->test_bb = emit_block();

17✔

6841

      emit_jump(it->test_bb);

38✔

6844

   vcode_select_block(false_bb);

279✔

6845

279✔

6847

static void lower_case_scalar(lower_unit_t *lu, tree_t stmt,

260✔

6850

   const int nstmts = tree_stmts(stmt);

260✔

6851

   const bool want_coverage = cover_enabled(lu->cover, COVER_MASK_BRANCH);

260✔

6853

   vcode_block_t def_bb = VCODE_INVALID_BLOCK;

260✔

6854

   vcode_block_t exit_bb = emit_block();

260✔

6856

   vcode_reg_t value_reg = lower_rvalue(lu, tree_value(stmt));

260✔

6858

   int nchoices = 0;

260✔

6859

   for (int i = 0; i < nstmts; i++) {

1,410✔

6860

      tree_t alt = tree_stmt(stmt, i);

1,150✔

6862

      const int nassocs = tree_assocs(alt);

1,150✔

6863

      nchoices += nassocs;

1,150✔

6865

      for (int j = 0; j < nassocs; j++) {

2,692✔

6866

         tree_t a = tree_assoc(alt, j);

1,542✔

6869

         if (tree_subkind(a) == A_RANGE) {

1,542✔

6870

            tree_t r = tree_range(a, 0);

17✔

6871

            vcode_reg_t left_reg = lower_range_left(lu, r);

17✔

6872

            vcode_reg_t right_reg = lower_range_right(lu, r);

17✔

6874

            const range_kind_t dir = tree_subkind(r);

17✔

6875

            vcode_reg_t low_reg = dir == RANGE_TO ? left_reg : right_reg;

17✔

6876

            vcode_reg_t high_reg = dir == RANGE_TO ? right_reg : left_reg;

17✔

6878

            vcode_reg_t lcmp_reg = emit_cmp(VCODE_CMP_GEQ, value_reg, low_reg);

17✔

6879

            vcode_reg_t hcmp_reg = emit_cmp(VCODE_CMP_LEQ, value_reg, high_reg);

17✔

6880

            vcode_reg_t hit_reg = emit_and(lcmp_reg, hcmp_reg);

17✔

6882

            vcode_block_t skip_bb = emit_block();

17✔

6883

            vcode_block_t hit_bb = emit_block();

17✔

6885

            emit_cond(hit_reg, hit_bb, skip_bb);

17✔

6887

            if (want_coverage) {

17✔

6888

               PUSH_COVER_SCOPE(lu, a);

2✔

6889

               lower_branch_coverage(lu, a, hit_bb, VCODE_INVALID_BLOCK);

1✔

6892

            vcode_select_block(hit_bb);

17✔

6894

            lower_sequence(lu, alt, loops);

17✔

6896

            if (!vcode_block_finished())

17✔

6897

               emit_jump(exit_bb);

17✔

6899

            vcode_select_block(skip_bb);

17✔

6904

   vcode_block_t start_bb = vcode_active_block();

260✔

6906

   vcode_reg_t *cases LOCAL = xcalloc_array(nchoices, sizeof(vcode_reg_t));

520✔

6907

   vcode_block_t *blocks LOCAL = xcalloc_array(nchoices, sizeof(vcode_block_t));

520✔

6909

   int cptr = 0;

260✔

6910

   for (int i = 0; i < nstmts; i++) {

1,410✔

6911

      tree_t alt = tree_stmt(stmt, i);

1,150✔

6912

      vcode_block_t hit_bb = VCODE_INVALID_BLOCK;

1,150✔

6914

      const int nassocs = tree_assocs(alt);

1,150✔

6915

      for (int j = 0; j < nassocs; j++) {

2,692✔

6916

         tree_t a = tree_assoc(alt, j);

1,542✔

6917

         const assoc_kind_t kind = tree_subkind(a);

1,542✔

6919

         if (kind == A_RANGE)

1,542✔

6920

            continue;    // Handled separately above

17✔

6922

         PUSH_COVER_SCOPE(lu, a);

3,050✔

6924

         if (hit_bb == VCODE_INVALID_BLOCK)

1,525✔

6925

            hit_bb = emit_block();

1,136✔

6928

         vcode_block_t cover_bb = hit_bb;

1,525✔

6929

         if (want_coverage && nassocs > 1)

1,525✔

6930

            cover_bb = emit_block();

5✔

6932

         if (kind == A_OTHERS) {

1,525✔

6933

            assert(def_bb == VCODE_INVALID_BLOCK);

192✔

6934

            if (want_coverage) {

192✔

6935

               def_bb = cover_bb;

16✔

6936

               lower_branch_coverage(lu, a, cover_bb, VCODE_INVALID_BLOCK);

16✔

6942

            vcode_select_block(start_bb);

1,333✔

6943

            cases[cptr] = lower_rvalue(lu, tree_name(a));

1,333✔

6945

            if (want_coverage) {

1,333✔

6946

               blocks[cptr] = cover_bb;

77✔

6947

               lower_branch_coverage(lu, a, cover_bb, VCODE_INVALID_BLOCK);

77✔

6950

               blocks[cptr] = hit_bb;

1,256✔

6952

            cptr++;

1,333✔

6955

         if (cover_bb != hit_bb) {

1,525✔

6956

            vcode_select_block(cover_bb);

5✔

6957

            emit_jump(hit_bb);

5✔

6961

      if (hit_bb == VCODE_INVALID_BLOCK)

1,150✔

6962

         continue;

14✔

6964

      vcode_select_block(hit_bb);

1,136✔

6966

      lower_sequence(lu, alt, loops);

1,136✔

6968

      if (!vcode_block_finished())

1,136✔

6969

         emit_jump(exit_bb);

879✔

6972

   assert(cptr <= nchoices);

260✔

6974

   if (def_bb == VCODE_INVALID_BLOCK)

260✔

6975

      def_bb = exit_bb;

68✔

6977

   vcode_select_block(start_bb);

260✔

6979

   emit_case(value_reg, def_bb, cases, blocks, cptr);

260✔

6980

   vcode_select_block(exit_bb);

260✔

6981

260✔

6983

static void lower_case_array(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

86✔

6985

   vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX);

86✔

6986

   vcode_type_t voffset = vtype_offset();

86✔

6988

   tree_t value = tree_value(stmt);

86✔

6989

   type_t type = tree_type(value);

86✔

6990

   vcode_reg_t val_reg = lower_rvalue(lu, tree_value(stmt));

86✔

6991

   vcode_reg_t data_ptr = lower_array_data(val_reg);

86✔

6993

   vcode_block_t def_bb   = VCODE_INVALID_BLOCK;

86✔

6994

   vcode_block_t exit_bb  = emit_block();

86✔

6995

   vcode_block_t hit_bb   = VCODE_INVALID_BLOCK;

86✔

6996

   vcode_block_t start_bb = vcode_active_block();

86✔

6998

   int64_t length = INT64_MAX;

86✔

6999

   if (type_is_unconstrained(type)

86✔

7000

       || !folded_length(range_of(type, 0), &length)) {

77✔

7001

      vcode_reg_t length_reg = lower_array_len(lu, type, 0, val_reg);

12✔

7004

      vcode_reg_t c0_length_reg;

12✔

7005

      tree_t a0 = tree_assoc(tree_stmt(stmt, 0), 0);

12✔

7006

      if (tree_subkind(a0) == A_NAMED) {

12✔

7007

         tree_t c0 = tree_name(a0);

12✔

7008

         vcode_reg_t c0_reg = lower_rvalue(lu, c0);

12✔

7009

         c0_length_reg = lower_array_len(lu, tree_type(c0), 0, c0_reg);

12✔

7014

      if (!vcode_reg_const(length_reg, &length)) {

12✔

7015

         if (!vcode_reg_const(c0_length_reg, &length)) {

6✔

7022

      vcode_reg_t locus = lower_debug_locus(stmt);

12✔

7023

      emit_length_check(c0_length_reg, length_reg, locus, VCODE_INVALID_REG);

12✔

7026

   type_t base = type_base_recur(type_elem(type));

86✔

7027

   assert(type_kind(base) == T_ENUM);

86✔

7029

   const int nbits = ilog2(type_enum_literals(base));

86✔

7030

   const bool exact_map = length * nbits <= 64;

86✔

7034

   static const int max_cases = 256;

86✔

7036

   if (!exact_map) {

86✔

7039

      if (vcode_reg_kind(val_reg) != VCODE_TYPE_UARRAY)

6✔

7040

         val_reg = lower_wrap(lu, type, val_reg);

3✔

7043

   vcode_type_t enc_type = VCODE_INVALID_TYPE;

86✔

7044

   vcode_reg_t enc_reg = VCODE_INVALID_REG;

86✔

7045

   if (exact_map && length <= 4) {

86✔

7047

      enc_type = voffset;

67✔

7048

      enc_reg = emit_const(enc_type, 0);

67✔

7049

      for (int64_t i = 0; i < length; i++) {

299✔

7050

         vcode_reg_t i_reg = emit_const(voffset, i);

232✔

7051

         vcode_reg_t ptr_reg = emit_array_ref(data_ptr, i_reg);

232✔

7052

         vcode_reg_t byte_reg = emit_load_indirect(ptr_reg);

232✔

7053

         enc_reg = emit_mul(enc_reg, emit_const(enc_type, 1 << nbits));

232✔

7054

         enc_reg = emit_add(enc_reg, emit_cast(enc_type, enc_type, byte_reg));

232✔

7058

      enc_type = vint64;

19✔

7059

      vcode_var_t enc_var = lower_temp_var(lu, "enc", enc_type, enc_type);

19✔

7060

      emit_store(emit_const(enc_type, 0), enc_var);

19✔

7062

      vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

19✔

7063

      emit_store(emit_const(voffset, 0), i_var);

19✔

7065

      vcode_block_t body_bb = emit_block();

19✔

7066

      vcode_block_t exit_bb = start_bb = emit_block();

19✔

7068

      emit_jump(body_bb);

19✔

7070

      vcode_select_block(body_bb);

19✔

7072

      vcode_reg_t i_reg    = emit_load(i_var);

19✔

7073

      vcode_reg_t ptr_reg  = emit_array_ref(data_ptr, i_reg);

19✔

7074

      vcode_reg_t byte_reg = emit_load_indirect(ptr_reg);

19✔

7075

      vcode_reg_t tmp_reg  = emit_load(enc_var);

19✔

7077

      if (exact_map)

19✔

7078

         tmp_reg = emit_mul(tmp_reg, emit_const(enc_type, 1 << nbits));

13✔

7080

         tmp_reg = emit_mul(tmp_reg, emit_const(enc_type, 0x27d4eb2d));

6✔

7081

      tmp_reg = emit_add(tmp_reg, emit_cast(enc_type, enc_type, byte_reg));

19✔

7082

      emit_store(tmp_reg, enc_var);

19✔

7084

      vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1));

19✔

7085

      emit_store(i_next, i_var);

19✔

7087

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next,

19✔

7089

      emit_cond(done_reg, exit_bb, body_bb);

19✔

7091

      vcode_select_block(exit_bb);

19✔

7093

      enc_reg = emit_load(enc_var);

19✔

7095

      if (!exact_map)

19✔

7096

         enc_reg = emit_rem(enc_reg, emit_const(enc_type, max_cases));

6✔

7098

      lower_release_temp(lu, i_var);

19✔

7099

      lower_release_temp(lu, enc_var);

19✔

7102

   int nchoices = 0;

86✔

7103

   const int nstmts = tree_stmts(stmt);

86✔

7104

   for (int i = 0; i < nstmts; i++)

642✔

7105

      nchoices += tree_assocs(tree_stmt(stmt, i));

556✔

7107

   vcode_reg_t *cases LOCAL = xcalloc_array(nchoices, sizeof(vcode_reg_t));

172✔

7108

   vcode_block_t *blocks LOCAL = xcalloc_array(nchoices, sizeof(vcode_block_t));

172✔

7109

   int64_t *encoding LOCAL = xcalloc_array(nchoices, sizeof(int64_t));

172✔

7111

   ident_t cmp_func = NULL;

86✔

7112

   vcode_type_t vbool = vtype_bool();

86✔

7113

   vcode_block_t fallthrough_bb = VCODE_INVALID_BLOCK;

86✔

7115

   if (!exact_map) {

86✔

7116

      fallthrough_bb = emit_block();

6✔

7117

      cmp_func = lower_predef_func_name(tree_type(value), "=");

6✔

7120

   int cptr = 0;

86✔

7121

   for (int i = 0; i < nstmts; i++) {

642✔

7122

      tree_t alt = tree_stmt(stmt, i);

556✔

7124

      const int nassocs = tree_assocs(alt);

556✔

7125

      for (int j = 0; j < nassocs; j++) {

1,142✔

7126

         tree_t a = tree_assoc(alt, j);

586✔

7127

         const assoc_kind_t kind = tree_subkind(a);

586✔

7128

         assert(kind != A_RANGE);

586✔

7130

         hit_bb = emit_block();

586✔

7132

         PUSH_COVER_SCOPE(lu, a);

1,172✔

7134

         if (kind == A_OTHERS) {

586✔

7135

            assert(def_bb == VCODE_INVALID_BLOCK);

76✔

7136

            def_bb = hit_bb;

76✔

7138

             if (cover_enabled(lu->cover, COVER_MASK_BRANCH))

76✔

7139

                lower_branch_coverage(lu, a, hit_bb, VCODE_INVALID_BLOCK);

6✔

7142

            tree_t name = tree_name(a);

510✔

7143

            const int exact_bits = exact_map ? nbits : 0;

510✔

7144

            int64_t enc = encode_case_choice(name, length, exact_bits);

510✔

7145

            if (!exact_map) enc %= max_cases;

510✔

7147

            vcode_block_t entry_bb = hit_bb;

510✔

7148

            bool have_dup = false;

510✔

7149

            if (!exact_map) {

510✔

7151

               vcode_block_t chain_bb = fallthrough_bb;

513✔

7152

               for (int k = 0; k < cptr; k++) {

513✔

7153

                  if (encoding[k] == enc) {

459✔

7154

                     chain_bb  = blocks[k];

3✔

7155

                     blocks[k] = hit_bb;

3✔

7156

                     have_dup  = true;

3✔

7157

                     break;

3✔

7161

               vcode_select_block(hit_bb);

57✔

7162

               hit_bb = emit_block();

57✔

7164

               vcode_reg_t name_reg = lower_rvalue(lu, name);

57✔

7165

               if (vcode_reg_kind(name_reg) != VCODE_TYPE_UARRAY)

57✔

7166

                  name_reg = lower_wrap(lu, tree_type(name), name_reg);

57✔

7168

               vcode_reg_t context_reg = lower_context_for_call(lu, cmp_func);

57✔

7169

               vcode_reg_t args[] = { context_reg, name_reg, val_reg };

57✔

7170

               vcode_reg_t eq_reg = emit_fcall(cmp_func, vbool, vbool, args, 3);

57✔

7171

               emit_cond(eq_reg, hit_bb, chain_bb);

57✔

7174

            if (!have_dup) {

510✔

7175

               vcode_select_block(start_bb);

507✔

7176

               cases[cptr]    = emit_const(enc_type, enc);

507✔

7177

               blocks[cptr]   = entry_bb;

507✔

7178

               encoding[cptr] = enc;

507✔

7181

               if (cover_enabled(lu->cover, COVER_MASK_BRANCH))

507✔

7182

                  lower_branch_coverage(lu, a, hit_bb, VCODE_INVALID_BLOCK);

51✔

7184

               cptr++;

507✔

7188

         vcode_select_block(hit_bb);

586✔

7190

         lower_sequence(lu, alt, loops);

586✔

7192

         if (!vcode_block_finished())

586✔

7193

            emit_jump(exit_bb);

454✔

7197

   assert(cptr <= nchoices);

86✔

7199

   if (def_bb == VCODE_INVALID_BLOCK)

86✔

7200

      def_bb = exit_bb;

10✔

7202

   if (fallthrough_bb != VCODE_INVALID_BLOCK) {

86✔

7203

      vcode_select_block(fallthrough_bb);

6✔

7204

      emit_jump(def_bb);

6✔

7207

   vcode_select_block(start_bb);

86✔

7209

   emit_case(enc_reg, def_bb, cases, blocks, cptr);

86✔

7211

   vcode_select_block(exit_bb);

86✔

7214

static void lower_case(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

346✔

7216

   lower_stmt_coverage(lu, stmt);

346✔

7218

   if (type_is_scalar(tree_type(tree_value(stmt))))

346✔

7219

      lower_case_scalar(lu, stmt, loops);

260✔

7221

      lower_case_array(lu, stmt, loops);

86✔

7222

346✔

7224

static void lower_match_case(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

36✔

7226

   vcode_block_t exit_bb = VCODE_INVALID_BLOCK;

36✔

7228

   tree_t value = tree_value(stmt);

36✔

7229

   type_t type = tree_type(value);

36✔

7231

   const bool is_array = type_is_array(type);

36✔

7232

   type_t scalar = is_array ? type_elem(type) : type;

36✔

7234

   if (type_eq(scalar, std_type(NULL, STD_BIT))) {

36✔

7237

      lower_case(lu, stmt, loops);

6✔

7238

      return;

6✔

7241

   vcode_reg_t value_reg = lower_rvalue(lu, value);

30✔

7242

   if (is_array && vcode_reg_kind(value_reg) != VCODE_TYPE_UARRAY)

30✔

7243

      value_reg = lower_wrap(lu, type, value_reg);

21✔

7247

      ident_t func = ident_new(

36✔

7250

      vcode_reg_t context_reg = lower_context_for_call(lu, func);

30✔

7252

      vcode_reg_t args[] = { context_reg, value_reg };

30✔

7253

      emit_fcall(func, VCODE_INVALID_REG, VCODE_INVALID_REG,

30✔

7257

   ident_t func = ident_new(is_array ? "IEEE.STD_LOGIC_1164.\"?=\"(YY)U$predef"

36✔

7259

   vcode_reg_t context_reg = lower_context_for_call(lu, func);

30✔

7261

   vcode_type_t vscalar = lower_type(scalar);

30✔

7262

   vcode_reg_t true_reg = emit_const(vscalar, 3);  // STD_LOGIC'POS('1')

30✔

7264

   const int nstmts = tree_stmts(stmt);

30✔

7265

   for (int i = 0; i < nstmts; i++) {

147✔

7266

      tree_t alt = tree_stmt(stmt, i);

117✔

7268

      vcode_block_t hit_bb = emit_block();

117✔

7269

      vcode_block_t skip_bb = VCODE_INVALID_BLOCK;

117✔

7271

      const int nassocs = tree_assocs(alt);

117✔

7272

      for (int j = 0; j < nassocs; j++) {

237✔

7273

         vcode_block_t loop_bb = VCODE_INVALID_BLOCK;

120✔

7274

         vcode_reg_t test_reg = VCODE_INVALID_REG;

120✔

7275

         vcode_var_t tmp_var = VCODE_INVALID_VAR;

120✔

7277

         tree_t a = tree_assoc(alt, j);

120✔

7278

         switch (tree_subkind(a)) {

120✔

7279

         case A_NAMED:

90✔

7281

               tree_t name = tree_name(a);

90✔

7282

               test_reg = lower_rvalue(lu, name);

90✔

7284

               if (is_array && vcode_reg_kind(test_reg) != VCODE_TYPE_UARRAY)

90✔

7285

                  test_reg = lower_wrap(lu, tree_type(name), test_reg);

84✔

7287

               skip_bb = emit_block();

90✔

7289

            break;

90✔

7291

         case A_RANGE:

6✔

7293

               tree_t r = tree_range(a, 0);

6✔

7294

               vcode_reg_t left_reg  = lower_range_left(lu, r);

6✔

7295

               vcode_reg_t right_reg = lower_range_right(lu, r);

6✔

7296

               vcode_reg_t dir_reg   = lower_range_dir(lu, r);

6✔

7298

               if (tmp_var == VCODE_INVALID_VAR)

6✔

7299

                  tmp_var = lower_temp_var(lu, "i", vscalar, vscalar);

6✔

7301

               emit_store(left_reg, tmp_var);

6✔

7303

               vcode_reg_t null_reg  =

6✔

7304

                  emit_range_null(left_reg, right_reg, dir_reg);

6✔

7306

               vcode_block_t body_bb = emit_block();

6✔

7307

               loop_bb = emit_block();

6✔

7308

               skip_bb = emit_block();

6✔

7310

               emit_cond(null_reg, skip_bb, body_bb);

6✔

7312

               vcode_select_block(body_bb);

6✔

7314

               test_reg = emit_load(tmp_var);

6✔

7316

               vcode_select_block(loop_bb);

6✔

7318

               vcode_reg_t step_down = emit_const(vscalar, -1);

6✔

7319

               vcode_reg_t step_up   = emit_const(vscalar, 1);

6✔

7320

               vcode_reg_t step_reg  = emit_select(dir_reg, step_down, step_up);

6✔

7321

               vcode_reg_t next_reg  = emit_add(test_reg, step_reg);

6✔

7322

               emit_store(next_reg, tmp_var);

6✔

7324

               vcode_reg_t done_reg =

6✔

7325

                  emit_cmp(VCODE_CMP_EQ, test_reg, right_reg);

6✔

7326

               emit_cond(done_reg, skip_bb, body_bb);

6✔

7328

               vcode_select_block(body_bb);

6✔

7330

            break;

6✔

7332

         case A_OTHERS:

24✔

7333

            emit_jump(hit_bb);

24✔

7334

            continue;

24✔

7337

         vcode_reg_t args[] = {

96✔

7342

         vcode_reg_t result_reg = emit_fcall(func, vscalar, vscalar,

96✔

7344

         vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_EQ, result_reg, true_reg);

96✔

7346

         if (loop_bb != VCODE_INVALID_BLOCK)

96✔

7347

            emit_cond(cmp_reg, hit_bb, loop_bb);

6✔

7349

            emit_cond(cmp_reg, hit_bb, skip_bb);

90✔

7351

         vcode_select_block(skip_bb);

96✔

7353

         if (tmp_var != VCODE_INVALID_VAR)

96✔

7354

            lower_release_temp(lu, tmp_var);

6✔

7357

      vcode_select_block(hit_bb);

117✔

7358

      lower_sequence(lu, alt, loops);

117✔

7360

      if (!vcode_block_finished()) {

117✔

7361

         if (exit_bb == VCODE_INVALID_BLOCK)

105✔

7362

            exit_bb = emit_block();

27✔

7363

         emit_jump(exit_bb);

105✔

7366

      if (skip_bb != VCODE_INVALID_BLOCK)

117✔

7367

         vcode_select_block(skip_bb);

93✔

7370

   if (exit_bb != VCODE_INVALID_BLOCK) {

30✔

7371

      if (!vcode_block_finished())

27✔

7372

         emit_jump(exit_bb);

6✔

7373

      vcode_select_block(exit_bb);

27✔

7377

static void lower_sequential_block(lower_unit_t *lu, tree_t stmt,

408✔

7380

   lower_decls(lu, stmt);

408✔

7381

   lower_sequence(lu, stmt, loops);

408✔

7382

408✔

7384

static void lower_stmt(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops)

75,108✔

7386

   if (vcode_block_finished())

75,108✔

7387

      return;   // Unreachable

13✔

7389

   PUSH_DEBUG_INFO(stmt);

75,095✔

7390

   PUSH_COVER_SCOPE(lu, stmt);

150,190✔

7392

   switch (tree_kind(stmt)) {

75,095✔

7393

   case T_ASSERT:

14,028✔

7394

      lower_assert(lu, stmt);

14,028✔

7395

      break;

14,028✔

7396

   case T_REPORT:

1,989✔

7397

      lower_report(lu, stmt);

1,989✔

7398

      break;

1,989✔

7399

   case T_WAIT:

12,759✔

7400

      lower_wait(lu, stmt);

12,759✔

7401

      break;

12,759✔

7402

   case T_VAR_ASSIGN:

12,841✔

7403

      lower_var_assign(lu, stmt);

12,841✔

7404

      break;

12,841✔

7405

   case T_SIGNAL_ASSIGN:

8,265✔

7406

      lower_signal_assign(lu, stmt);

8,265✔

7407

      break;

8,265✔

7408

   case T_FORCE:

54✔

7409

      lower_force(lu, stmt);

54✔

7410

      break;

54✔

7411

   case T_RELEASE:

30✔

7412

      lower_release(lu, stmt);

30✔

7413

      break;

30✔

7414

   case T_IF:

5,604✔

7415

      lower_if(lu, stmt, loops);

5,604✔

7416

      break;

5,604✔

7417

   case T_RETURN:

9,538✔

7418

      lower_return(lu, stmt);

9,538✔

7419

      break;

9,538✔

7420

   case T_PCALL:

6,125✔

7422

      lower_pcall(lu, stmt);

6,125✔

7423

      break;

6,125✔

7424

   case T_WHILE:

183✔

7425

      lower_while(lu, stmt, loops);

183✔

7426

      break;

183✔

7427

   case T_LOOP:

101✔

7428

      lower_loop(lu, stmt, loops);

101✔

7429

      break;

101✔

7430

   case T_FOR:

2,210✔

7431

      lower_for(lu, stmt, loops);

2,210✔

7432

      break;

2,210✔

7433

   case T_SEQUENCE:

408✔

7434

      lower_sequential_block(lu, stmt, loops);

408✔

7435

      break;

408✔

7436

   case T_EXIT:

279✔

7438

      lower_loop_control(lu, stmt, loops);

279✔

7439

      break;

279✔

7440

   case T_CASE:

340✔

7441

      lower_case(lu, stmt, loops);

340✔

7442

      break;

340✔

7443

   case T_MATCH_CASE:

36✔

7444

      lower_match_case(lu, stmt, loops);

36✔

7445

      break;

36✔

7454

static void lower_check_indexes(lower_unit_t *lu, type_t from, type_t to,

9,715✔

7457

   const int ndims = dimension_of(to);

9,715✔

7458

   for (int i = 0; i < ndims; i++) {

20,183✔

7459

      type_t index = index_type_of(to, i);

10,468✔

7461

      vcode_reg_t ileft_reg, iright_reg, idir_reg;

10,468✔

7462

      lower_get_scalar_type_bounds(lu, index, &ileft_reg,

10,468✔

7465

      vcode_reg_t aleft_reg  = lower_array_left(lu, from, i, array);

10,468✔

7466

      vcode_reg_t aright_reg = lower_array_right(lu, from, i, array);

10,468✔

7467

      vcode_reg_t adir_reg   = lower_array_dir(lu, from, i, array);

10,468✔

7469

      vcode_reg_t null_reg = emit_range_null(aleft_reg, aright_reg, adir_reg);

10,468✔

7471

      vcode_block_t after_bb = VCODE_INVALID_BLOCK;

10,468✔

7473

      int64_t null_const;

10,468✔

7474

      if (vcode_reg_const(null_reg, &null_const)) {

10,468✔

7475

         if (null_const == 1)

5,206✔

7476

            continue;   // Array range is statically known to be null

137✔

7479

         vcode_block_t check_bb = emit_block();

5,262✔

7480

         after_bb = emit_block();

5,262✔

7481

         emit_cond(null_reg, after_bb, check_bb);

5,262✔

7482

         vcode_select_block(check_bb);

5,262✔

7485

      vcode_reg_t hint_reg;

10,331✔

7486

      if (type_is_unconstrained(to))

10,331✔

7487

         hint_reg = lower_debug_locus(range_of(index, 0));

2,418✔

7489

         hint_reg = lower_debug_locus(range_of(to, i));

7,913✔

7491

      vcode_reg_t locus = where ? lower_debug_locus(where) : hint_reg;

10,331✔

7493

      emit_index_check(aleft_reg, ileft_reg, iright_reg, idir_reg,

10,331✔

7495

      emit_index_check(aright_reg, ileft_reg, iright_reg, idir_reg,

10,331✔

7498

      if (after_bb != VCODE_INVALID_BLOCK) {

10,331✔

7499

         emit_jump(after_bb);

5,262✔

7500

         vcode_select_block(after_bb);

5,262✔

7503

9,715✔

7505

static vcode_reg_t lower_var_constraints(lower_unit_t *lu, type_t var_type,

925✔

7508

925✔

7509

   assert(type_is_array(var_type));

925✔

7510

   assert(type_is_array(init_type));

925✔

7512

   const int ncons = dims_for_type(var_type);

925✔

7513

   vcode_dim_t dims[ncons];

925✔

7514

   int dptr = 0;

925✔

7516

   int udims = 0;

925✔

7517

   if (have_array_metadata(init_type, init_reg))

925✔

7518

      udims = vtype_dims(vcode_reg_type(init_reg));

864✔

7520

   for (; dptr < ncons; init_type = type_elem(init_type),

2,805✔

7521

           var_type = type_elem(var_type)) {

940✔

7523

      tree_t c = NULL;

955✔

7524

      for (type_t iter = var_type; type_kind(iter) == T_SUBTYPE;

955✔

7525

           iter = type_base(iter)) {

15✔

7526

         if (type_has_constraint(iter)) {

861✔

7527

            tree_t c0 = type_constraint(iter);

846✔

7528

            if (tree_subkind(c0) == C_INDEX) {

846✔

7535

      const int ndims = dimension_of(var_type);

940✔

7536

      for (int i = 0; i < ndims; i++, dptr++) {

1,884✔

7537

         if (c != NULL) {

944✔

7538

            tree_t r = tree_range(c, i);

846✔

7539

            dims[dptr].left  = lower_range_left(lu, r);

846✔

7540

            dims[dptr].right = lower_range_right(lu, r);

846✔

7541

            dims[dptr].dir   = lower_range_dir(lu, r);

846✔

7543

         else if (dptr < udims) {

98✔

7544

            dims[dptr].left  = emit_uarray_left(init_reg, dptr);

92✔

7545

            dims[dptr].right = emit_uarray_right(init_reg, dptr);

92✔

7546

            dims[dptr].dir   = emit_uarray_dir(init_reg, dptr);

92✔

7549

            tree_t r = range_of(init_type, i);

6✔

7550

            dims[dptr].left  = lower_range_left(lu, r);

6✔

7551

            dims[dptr].right = lower_range_right(lu, r);

6✔

7552

            dims[dptr].dir   = lower_range_dir(lu, r);

6✔

7557

   assert(dptr == ncons);

925✔

7559

   return emit_wrap(mem_reg, dims, ncons);

925✔

7562

static void lower_var_decl(lower_unit_t *lu, tree_t decl)

15,588✔

7564

   type_t type = tree_type(decl);

15,588✔

7565

   vcode_type_t vtype = lower_type(type);

15,588✔

7566

   vcode_type_t vbounds = lower_bounds(type);

15,588✔

7567

   const bool is_const = tree_kind(decl) == T_CONST_DECL;

15,588✔

7569

   bool skip_copy = false;

15,588✔

7570

   if (is_const && !tree_has_value(decl)) {

15,588✔

7574

   else if (is_const && type_is_array(type)

15,280✔

7575

            && !type_const_bounds(type)  // TODO: remove this restriction

2,837✔

7576

            && lower_is_const(tree_value(decl))) {

263✔

7577

      skip_copy = true;   // Will be allocated in constant data

121✔

7580

   vcode_var_flags_t flags = 0;

15,280✔

7581

   if (is_const) flags |= VAR_CONST;

15,280✔

7583

   vcode_var_t var = emit_var(vtype, vbounds, tree_ident(decl), flags);

15,280✔

7584

   lower_put_vcode_obj(decl, var, lu);

15,280✔

7586

   if (type_is_protected(type)) {

15,280✔

7587

      vcode_reg_t obj_reg = lower_protected_init(lu, type, decl);

154✔

7588

      emit_store(obj_reg, var);

154✔

7589

      return;

154✔

7592

   emit_debug_info(tree_loc(decl));

15,126✔

7594

   vcode_reg_t bounds_reg = VCODE_INVALID_REG;

15,126✔

7595

   vcode_reg_t dest_reg  = VCODE_INVALID_REG;

15,126✔

7596

   vcode_reg_t count_reg = VCODE_INVALID_REG;

15,126✔

7597

   vcode_reg_t mem_reg = VCODE_INVALID_REG;

15,126✔

7599

   if (type_is_record(type))

15,126✔

7600

      dest_reg = emit_index(var, VCODE_INVALID_REG);

869✔

7601

   else if (type_is_array(type)) {

14,257✔

7602

      if (needs_bounds_var(type)) {

7,506✔

7603

         bounds_reg = lower_get_type_bounds(lu, type);

3,064✔

7604

         count_reg = lower_array_total_len(lu, type, bounds_reg);

3,064✔

7606

         vcode_type_t velem = lower_type(type_elem_recur(type));

3,064✔

7607

         mem_reg = emit_alloc(velem, vbounds, count_reg);

3,064✔

7609

         dest_reg = lower_rewrap(mem_reg, bounds_reg);

3,064✔

7610

         emit_store(dest_reg, var);

3,064✔

7612

      else if (!type_is_unconstrained(type)) {

4,442✔

7613

         count_reg = lower_array_total_len(lu, type, bounds_reg);

4,261✔

7614

         dest_reg = mem_reg = emit_index(var, VCODE_INVALID_REG);

4,261✔

7618

   type_t value_type = NULL;

15,126✔

7619

   vcode_reg_t value_reg;

15,126✔

7620

   if (tree_has_value(decl)) {

15,126✔

7621

      tree_t value = tree_value(decl);

7,785✔

7622

      value_type = tree_type(value);

7,785✔

7623

      if (tree_kind(value) == T_AGGREGATE)

7,785✔

7624

         value_reg = lower_aggregate(lu, value, dest_reg);

2,755✔

7626

         value_reg = lower_known_subtype(lu, value, type, bounds_reg);

5,030✔

7629

      value_type = type;

7,341✔

7630

      value_reg = lower_default_value(lu, type, dest_reg);

7,341✔

7633

   if (type_is_array(type)) {

15,126✔

7634

      vcode_reg_t data_reg = lower_array_data(value_reg);

7,506✔

7636

      if (is_const && skip_copy) {

7,506✔

7637

         vcode_reg_t wrap_reg =

121✔

7638

            lower_coerce_arrays(lu, value_type, type, value_reg);

121✔

7639

         emit_store(wrap_reg, var);

121✔

7641

      else if (type_is_unconstrained(type)) {

7,385✔

7642

         count_reg = lower_array_total_len(lu, value_type, value_reg);

88✔

7644

         type_t scalar_elem = type_elem_recur(type);

88✔

7645

         dest_reg = emit_alloc(lower_type(scalar_elem),

88✔

7648

         emit_copy(dest_reg, data_reg, count_reg);

88✔

7650

         vcode_reg_t wrap_reg =

88✔

7651

            lower_var_constraints(lu, type, value_type, value_reg, dest_reg);

88✔

7653

         vcode_reg_t locus = lower_debug_locus(decl);

88✔

7654

         lower_check_array_sizes(lu, type, value_type,

88✔

7657

         emit_store(wrap_reg, var);

88✔

7660

         vcode_reg_t locus = lower_debug_locus(decl);

7,297✔

7661

         lower_check_indexes(lu, value_type, type, value_reg, NULL);

7,297✔

7662

         lower_check_array_sizes(lu, type, value_type,

7,297✔

7664

         emit_copy(mem_reg, data_reg, count_reg);

7,297✔

7667

   else if (type_is_record(type))

7,620✔

7668

      lower_new_record(lu, type, dest_reg, value_reg);

869✔

7669

   else if (type_is_scalar(type)) {

6,751✔

7670

      lower_check_scalar_bounds(lu, value_reg, type, decl, decl);

6,126✔

7671

      emit_store(value_reg, var);

6,126✔

7673

   else if (type_is_access(type)) {

625✔

7674

      type_t designated = type_designated(type);

625✔

7675

      vcode_reg_t src_reg = lower_incomplete_access(value_reg, designated);

625✔

7676

      emit_store(src_reg, var);

625✔

7682

static vcode_reg_t lower_resolution_func(lower_unit_t *lu, type_t type,

17,952✔

7685

   tree_t rname = NULL;

23,802✔

7686

   for (type_t t = type; type_kind(t) == T_SUBTYPE; t = type_base(t)) {

32,948✔

7687

      if (type_has_resolution(t)) {

12,355✔

7688

         rname = type_resolution(t);

3,209✔

7689

         break;

3,209✔

7693

   if (rname == NULL && type_is_array(type))

23,802✔

7694

      return lower_resolution_func(lu, type_elem(type), is_array);

5,850✔

7695

   else if (rname == NULL)

17,952✔

7698

   while (tree_kind(rname) == T_ELEM_RESOLUTION) {

4,051✔

7699

      assert(type_is_array(type));

842✔

7700

      assert(tree_assocs(rname) == 1);

842✔

7702

      rname = tree_value(tree_assoc(rname, 0));

842✔

7703

      type = type_elem(type);

842✔

7706

   tree_t rdecl = tree_ref(rname);

3,209✔

7707

   ident_t rfunc = tree_ident2(rdecl);

3,209✔

7708

   vcode_type_t vtype = lower_type(type);

3,209✔

7710

   type_t uarray_param = type_param(tree_type(rdecl), 0);

3,209✔

7711

   assert(type_kind(uarray_param) == T_ARRAY);

3,209✔

7712

   tree_t r = range_of(type_index(uarray_param, 0), 0);

3,209✔

7714

   vcode_reg_t ileft_reg = emit_const(vtype_offset(), assume_int(tree_left(r)));

3,209✔

7716

   vcode_reg_t nlits_reg;

3,209✔

7717

   if (type_is_enum(type)) {

3,209✔

7719

      if (type_kind(type) == T_SUBTYPE) {

2,938✔

7720

         int64_t low, high;

2,099✔

7721

         range_bounds(range_of(type, 0), &low, &high);

2,099✔

7722

         nlits_reg = emit_const(vtype_offset(), high - low + 1);

2,099✔

7725

         nlits_reg = emit_const(vtype_offset(), type_enum_literals(type));

839✔

7728

      nlits_reg = emit_const(vtype_offset(), 0);

271✔

7730

   *is_array = vtype_kind(vtype) == VCODE_TYPE_CARRAY;

3,209✔

7732

   vcode_type_t elem = *is_array ? vtype_elem(vtype) : vtype;

3,209✔

7733

   vcode_type_t rtype = lower_func_result_type(type);

3,209✔

7734

   vcode_type_t atype = vtype_uarray(1, elem, vtype_int(0, INT32_MAX));

3,209✔

7736

   vcode_reg_t context_reg = lower_context_for_call(lu, rfunc);

3,209✔

7737

   vcode_reg_t closure_reg = emit_closure(rfunc, context_reg, atype, rtype);

3,209✔

7738

   return emit_resolution_wrapper(rtype, closure_reg, ileft_reg, nlits_reg);

3,209✔

7741

static void lower_sub_signals(lower_unit_t *lu, type_t type, type_t var_type,

18,105✔

7748

   bool has_scope = false;

18,105✔

7749

   if (resolution == VCODE_INVALID_REG)

18,105✔

7750

      resolution = lower_resolution_func(lu, type, &has_scope);

17,952✔

7752

   if (type_is_scalar(type)) {

18,105✔

7753

      vcode_type_t voffset = vtype_offset();

10,184✔

7754

      vcode_reg_t size_reg = emit_const(voffset, type_byte_width(type));

10,184✔

7755

      vcode_reg_t len_reg = emit_const(voffset, 1);

10,184✔

7756

      vcode_type_t vtype = lower_type(type);

10,184✔

7758

      vcode_reg_t locus = lower_debug_locus(where);

10,184✔

7760

      if (init_reg == VCODE_INVALID_REG)

10,184✔

7761

         init_reg = lower_scalar_type_left(lu, type);

7,948✔

7763

      lower_check_scalar_bounds(lu, init_reg, type, where, where);

10,184✔

7765

      assert(!has_scope);

10,184✔

7767

      well_known_t wk = is_well_known(type_ident(type_base_recur(type)));

10,184✔

7768

      if (wk == W_IEEE_ULOGIC || wk == W_IEEE_LOGIC)

10,184✔

7769

         flags |= SIG_F_STD_LOGIC;

1,681✔

7771

      vcode_reg_t flags_reg = emit_const(voffset, flags);

10,184✔

7772

      vcode_reg_t sig = emit_init_signal(vtype, len_reg, size_reg, init_reg,

10,184✔

7775

      if (resolution != VCODE_INVALID_REG)

10,184✔

7776

         emit_resolve_signal(sig, resolution);

1,913✔

7778

      if (sig_var != VCODE_INVALID_VAR)

10,184✔

7779

         emit_store(sig, sig_var);

6,749✔

7781

         emit_store_indirect(sig, sig_ptr);

3,435✔

7783

   else if (type_is_homogeneous(type)) {

7,921✔

7784

      assert(type_is_array(type));

5,687✔

7786

      vcode_type_t voffset = vtype_offset();

5,687✔

7787

      vcode_reg_t size_reg = emit_const(voffset, type_byte_width(type));

5,687✔

7788

      vcode_reg_t len_reg = lower_array_total_len(lu, type, bounds_reg);

5,687✔

7789

      vcode_type_t vtype = lower_type(type_elem_recur(type));

5,687✔

7791

      vcode_reg_t locus = lower_debug_locus(where);

5,687✔

7793

      if (init_reg == VCODE_INVALID_REG)

5,687✔

7794

         init_reg = lower_scalar_type_left(lu, type_elem_recur(type));

4,982✔

7796

         lower_check_array_sizes(lu, type, init_type, bounds_reg,

705✔

7798

         init_reg = lower_array_data(init_reg);

705✔

7801

      if (has_scope)

5,687✔

7802

         emit_array_scope(locus, lower_type(type));

3✔

7804

      well_known_t wk = is_well_known(type_ident(type_base_recur(type)));

5,687✔

7805

      if (wk == W_IEEE_ULOGIC_VECTOR || wk == W_IEEE_LOGIC_VECTOR)

5,687✔

7806

         flags |= SIG_F_STD_LOGIC;

983✔

7808

      vcode_reg_t flags_reg = emit_const(voffset, flags);

5,687✔

7809

      vcode_reg_t sig = emit_init_signal(vtype, len_reg, size_reg, init_reg,

5,687✔

7812

      if (resolution != VCODE_INVALID_REG)

5,687✔

7813

         emit_resolve_signal(sig, resolution);

1,410✔

7815

      if (bounds_reg != VCODE_INVALID_REG)

5,687✔

7816

         sig = lower_rewrap(sig, bounds_reg);

698✔

7818

         sig = lower_coerce_arrays(lu, type, var_type, sig);

4,989✔

7820

      if (sig_var != VCODE_INVALID_VAR)

5,687✔

7821

         emit_store(sig, sig_var);

3,515✔

7823

         emit_store_indirect(sig, sig_ptr);

2,172✔

7825

      if (has_scope)

5,687✔

7826

         emit_pop_scope();

3✔

7828

   else if (type_is_array(type)) {

2,234✔

7832

      type_t elem = type_elem_recur(type);

629✔

7834

      if (null_reg == VCODE_INVALID_REG || have_uarray_ptr(null_reg))

629✔

7835

         null_reg = emit_null(vtype_pointer(lower_type(elem)));

578✔

7837

      if (sig_ptr == VCODE_INVALID_REG)

629✔

7838

         sig_ptr = emit_index(sig_var, VCODE_INVALID_REG);

561✔

7840

      vcode_reg_t locus = lower_debug_locus(where);

629✔

7842

      if (init_reg != VCODE_INVALID_REG)

629✔

7843

         lower_check_array_sizes(lu, type, init_type, VCODE_INVALID_REG,

310✔

7846

      vcode_reg_t len_reg = lower_array_total_len(lu, type, bounds_reg);

629✔

7848

      if (have_uarray_ptr(sig_ptr)) {

629✔

7850

         vcode_type_t vtype = lower_signal_type(elem);

421✔

7851

         vcode_type_t vbounds = lower_bounds(elem);

421✔

7852

         vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, len_reg);

421✔

7854

         vcode_reg_t wrap_reg;

421✔

7855

         if (bounds_reg != VCODE_INVALID_REG)

421✔

7856

            wrap_reg = lower_rewrap(mem_reg, bounds_reg);

404✔

7858

            wrap_reg = lower_wrap(lu, type, mem_reg);

17✔

7860

         emit_store_indirect(wrap_reg, sig_ptr);

421✔

7862

         sig_ptr = mem_reg;

421✔

7865

      vcode_type_t voffset = vtype_offset();

629✔

7866

      vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

629✔

7867

      emit_store(emit_const(voffset, 0), i_var);

629✔

7869

      emit_array_scope(locus, lower_type(type));

629✔

7871

      vcode_block_t cmp_bb  = emit_block();

629✔

7872

      vcode_block_t body_bb = emit_block();

629✔

7873

      vcode_block_t exit_bb = emit_block();

629✔

7875

      emit_jump(cmp_bb);

629✔

7877

      vcode_select_block(cmp_bb);

629✔

7879

      vcode_reg_t i_reg  = emit_load(i_var);

629✔

7880

      vcode_reg_t eq_reg = emit_cmp(VCODE_CMP_EQ, i_reg, len_reg);

629✔

7881

      emit_cond(eq_reg, exit_bb, body_bb);

629✔

7883

      vcode_select_block(body_bb);

629✔

7885

      vcode_reg_t ptr_reg = emit_array_ref(sig_ptr, i_reg);

629✔

7886

      vcode_reg_t null_off_reg = emit_array_ref(null_reg, i_reg);

629✔

7888

      vcode_reg_t data_reg = VCODE_INVALID_REG;

629✔

7889

      if (init_reg != VCODE_INVALID_REG)

629✔

7890

         data_reg = emit_array_ref(lower_array_data(init_reg), i_reg);

310✔

7892

      vcode_reg_t ebounds_reg = VCODE_INVALID_REG;

629✔

7893

      if (bounds_reg != VCODE_INVALID_REG && type_is_unconstrained(elem))

629✔

7894

         ebounds_reg = emit_unwrap(bounds_reg);

9✔

7896

      lower_sub_signals(lu, elem, elem, elem, where, view, VCODE_INVALID_VAR,

629✔

7900

      emit_store(emit_add(i_reg, emit_const(voffset, 1)), i_var);

629✔

7902

      emit_jump(cmp_bb);

629✔

7904

      vcode_select_block(exit_bb);

629✔

7905

      emit_pop_scope();

629✔

7906

      lower_release_temp(lu, i_var);

629✔

7908

   else if (type_is_record(type)) {

1,605✔

7909

      vcode_type_t vtype = lower_type(type);

1,605✔

7910

      emit_record_scope(lower_debug_locus(where), vtype);

1,605✔

7912

      if (null_reg == VCODE_INVALID_REG)

1,605✔

7913

         null_reg = emit_null(vtype_pointer(vtype));

747✔

7915

      if (sig_ptr == VCODE_INVALID_REG)

1,605✔

7916

         sig_ptr = emit_index(sig_var, VCODE_INVALID_REG);

747✔

7918

      type_t base = type_base_recur(type);

1,605✔

7920

      const int nfields = type_fields(base);

1,605✔

7921

      for (int i = 0; i < nfields; i++) {

7,509✔

7922

         tree_t f = type_field(base, i);

5,904✔

7924

         type_t ft = tree_type(f), et = ft;

5,904✔

7925

         if (base != type && type_is_unconstrained(ft)) {

5,904✔

7926

            tree_t ec = type_constraint_for_field(type, f);

411✔

7927

            if (ec != NULL)

411✔

7928

               et = tree_type(ec);

408✔

7931

         sig_flags_t newflags = flags;

5,904✔

7932

         tree_t fview = NULL;

5,904✔

7933

         if (view != NULL) {

5,904✔

7934

            bool converse = false;

126✔

7935

            tree_t e = find_element_mode_indication(view, f, &converse);

126✔

7936

            assert(e != NULL);

126✔

7938

            switch (tree_subkind(e)) {

126✔

7939

            case PORT_INOUT:

6✔

7940

               newflags |= NET_F_EFFECTIVE | NET_F_INOUT;

6✔

7941

               break;

6✔

7942

            case PORT_ARRAY_VIEW:

6✔

7944

               fview = tree_value(e);

6✔

7945

               break;

6✔

7949

         vcode_type_t fvtype = vtype_field(vtype, i);

5,904✔

7951

         vcode_reg_t null_field_reg;

5,904✔

7952

         if (vtype_kind(fvtype) == VCODE_TYPE_UARRAY)

5,904✔

7953

            null_field_reg = emit_null(vtype_pointer(fvtype));

592✔

7955

            null_field_reg = emit_record_ref(null_reg, i);

5,312✔

7957

         vcode_reg_t field_reg = VCODE_INVALID_REG;

5,904✔

7958

         if (init_reg != VCODE_INVALID_REG) {

5,904✔

7959

            field_reg = emit_record_ref(init_reg, i);

1,020✔

7961

            if (have_uarray_ptr(field_reg))

1,020✔

7962

               field_reg = emit_load_indirect(field_reg);

59✔

7963

            else if (type_is_scalar(ft))

961✔

7964

               field_reg = emit_load_indirect(field_reg);

826✔

7967

         vcode_reg_t fbounds_reg = VCODE_INVALID_REG;

5,904✔

7968

         if (bounds_reg != VCODE_INVALID_REG && type_is_unconstrained(ft)) {

5,904✔

7969

            fbounds_reg = emit_record_ref(bounds_reg, i);

190✔

7971

            if (have_uarray_ptr(fbounds_reg))

190✔

7972

               fbounds_reg = emit_load_indirect(fbounds_reg);

190✔

7975

         vcode_reg_t ptr_reg = emit_record_ref(sig_ptr, i);

5,904✔

7977

         lower_sub_signals(lu, et, ft, ft, f, fview, VCODE_INVALID_VAR, ptr_reg,

5,904✔

7982

      emit_pop_scope();

1,605✔

7986

18,105✔

7988

static void lower_signal_decl(lower_unit_t *lu, tree_t decl)

6,749✔

7990

   type_t type = tree_type(decl);

6,749✔

7991

   vcode_type_t vtype = lower_signal_type(type);

6,749✔

7992

   vcode_type_t vbounds = lower_bounds(type);

6,749✔

7993

   vcode_var_t var = emit_var(vtype, vbounds, tree_ident(decl), VAR_SIGNAL);

6,749✔

7994

   lower_put_vcode_obj(decl, var, lu);

6,749✔

7996

   type_t value_type = type;

6,749✔

7997

   vcode_reg_t init_reg = VCODE_INVALID_REG;

6,749✔

7998

   if (tree_has_value(decl)) {

6,749✔

7999

      tree_t value = tree_value(decl);

1,984✔

8000

      value_type = tree_type(value);

1,984✔

8001

      init_reg = lower_known_subtype(lu, value, type, VCODE_INVALID_REG);

1,984✔

8004

   vcode_reg_t bounds_reg = VCODE_INVALID_REG;

6,749✔

8005

   if (standard() >= STD_19 && type_is_unconstrained(type)) {

6,749✔

8009

   else if (needs_bounds_var(type))

6,743✔

8010

      bounds_reg = lower_get_type_bounds(lu, type);

578✔

8012

   sig_flags_t flags = 0;

6,749✔

8013

   if (tree_flags(decl) & TREE_F_REGISTER)

6,749✔

8014

      flags |= SIG_F_REGISTER;

3✔

8016

   lower_sub_signals(lu, type, type, value_type, decl, NULL, var,

6,749✔

8020

   PUSH_COVER_SCOPE(lu, decl);

13,498✔

8022

   if (cover_enabled(lu->cover, COVER_MASK_TOGGLE))

6,749✔

8023

      lower_toggle_coverage(lu, decl);

290✔

8025

   if (cover_enabled(lu->cover, COVER_MASK_STATE))

6,749✔

8026

      lower_state_coverage(lu, decl);

148✔

8027

6,749✔

8029

static void lower_build_wait_field_cb(lower_unit_t *lu, tree_t field,

15✔

8033

   type_t ftype = tree_type(field);

15✔

8035

   if (type_is_homogeneous(ftype)) {

15✔

8036

      vcode_reg_t nets_reg = emit_load_indirect(ptr);

15✔

8037

      vcode_reg_t count_reg = lower_type_width(lu, ftype, nets_reg);

15✔

8038

      vcode_reg_t data_reg = lower_array_data(nets_reg);

15✔

8039

      emit_sched_event(data_reg, count_reg);

15✔

8044

15✔

8046

static void lower_build_wait_cb(tree_t expr, void *ctx)

133✔

8048

   lower_unit_t *lu = ctx;

133✔

8049

   type_t type = tree_type(expr);

133✔

8051

   vcode_reg_t nets_reg = lower_lvalue(lu, expr);

133✔

8053

   if (type_is_homogeneous(type)) {

133✔

8054

      vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

121✔

8055

      vcode_reg_t data_reg = lower_array_data(nets_reg);

121✔

8056

      emit_sched_event(data_reg, count_reg);

121✔

8059

      lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG,

12✔

8061

133✔

8063

static void lower_implicit_field_cb(lower_unit_t *lu, tree_t field,

9✔

8067

   vcode_reg_t sig_reg = (intptr_t)ctx;

9✔

8068

   type_t ftype = tree_type(field);

9✔

8070

   if (type_is_homogeneous(ftype)) {

9✔

8071

      vcode_reg_t nets_reg = emit_load_indirect(ptr);

9✔

8072

      vcode_reg_t count_reg = lower_type_width(lu, ftype, nets_reg);

9✔

8073

      vcode_reg_t data_reg = lower_array_data(nets_reg);

9✔

8075

      emit_map_implicit(data_reg, sig_reg, count_reg);

9✔

8080

9✔

8082

static void lower_implicit_decl(lower_unit_t *parent, tree_t decl)

159✔

8084

   ident_t name = tree_ident(decl);

159✔

8085

   type_t type = tree_type(decl);

159✔

8086

   const implicit_kind_t kind = tree_subkind(decl);

159✔

8088

   vcode_type_t signal_type = lower_signal_type(type);

159✔

8089

   vcode_type_t vtype = lower_type(type);

159✔

8090

   vcode_type_t vbounds = lower_bounds(type);

159✔

8091

   vcode_var_t var = emit_var(signal_type, vbounds, name, VAR_SIGNAL);

159✔

8092

   lower_put_vcode_obj(decl, var, parent);

159✔

8094

   switch (kind) {

159✔

8095

   case IMPLICIT_GUARD:

21✔

8097

         tree_t expr = tree_value(decl);

21✔

8099

         ident_t qual = ident_prefix(parent->name, name, '.');

21✔

8100

         ident_t func = ident_prefix(qual, ident_new("guard"), '$');

21✔

8102

         vcode_state_t state;

21✔

8103

         vcode_state_save(&state);

21✔

8105

         object_t *obj = tree_to_object(expr);

21✔

8106

         vcode_unit_t vu = emit_function(func, obj, parent->vunit);

21✔

8107

         vcode_set_result(vtype);

21✔

8109

         vcode_type_t vcontext = vtype_context(parent->name);

21✔

8110

         emit_param(vcontext, vcontext, ident_new("context"));

21✔

8112

         lower_unit_t *lu = lower_unit_new(parent->registry, parent,

21✔

8114

         unit_registry_put(parent->registry, lu);

21✔

8116

         build_wait(expr, lower_build_wait_cb, lu);

21✔

8118

         emit_return(lower_rvalue(lu, expr));

21✔

8120

         unit_registry_finalise(parent->registry, lu);

21✔

8122

         vcode_state_restore(&state);

21✔

8124

         vcode_reg_t one_reg = emit_const(vtype_offset(), 1);

21✔

8125

         vcode_reg_t locus = lower_debug_locus(decl);

21✔

8126

         vcode_reg_t context_reg = lower_context_for_call(parent, func);

21✔

8127

         vcode_reg_t closure =

21✔

8128

            emit_closure(func, context_reg, VCODE_INVALID_TYPE, vtype);

21✔

8129

         vcode_reg_t delay_reg = emit_const(vtype_time(), TIME_HIGH);

21✔

8130

         vcode_reg_t kind_reg = emit_const(vtype_offset(), IMPLICIT_GUARD);

21✔

8131

         vcode_reg_t sig = emit_implicit_signal(vtype, one_reg, one_reg, locus,

21✔

8133

         emit_store(sig, var);

21✔

8135

      break;

21✔

8137

   case IMPLICIT_DELAYED:

84✔

8139

         tree_t wave = tree_value(decl);

84✔

8140

         assert(tree_kind(wave) == T_WAVEFORM);

84✔

8142

         tree_t expr = tree_value(wave);

84✔

8144

         vcode_reg_t init_reg =

84✔

8145

            lower_default_value(parent, type, VCODE_INVALID_REG);

84✔

8147

         lower_sub_signals(parent, type, type, type, decl, NULL, var,

84✔

8151

         vcode_state_t state;

84✔

8152

         vcode_state_save(&state);

84✔

8154

         object_t *obj = tree_to_object(decl);

84✔

8155

         ident_t name = ident_prefix(parent->name, tree_ident(decl), '.');

84✔

8156

         vcode_unit_t vu = emit_process(name, obj, parent->vunit);

84✔

8158

         lower_unit_t *lu = lower_unit_new(parent->registry, parent,

84✔

8160

         unit_registry_put(parent->registry, lu);

84✔

8162

         vcode_reg_t nets_reg = lower_signal_ref(lu, decl);

84✔

8164

         if (type_is_homogeneous(type)) {

84✔

8165

            vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

78✔

8166

            vcode_reg_t data_reg = lower_array_data(nets_reg);

78✔

8167

            emit_drive_signal(data_reg, count_reg);

78✔

8170

            lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG,

6✔

8173

         build_wait(expr, lower_build_wait_cb, lu);

84✔

8175

         emit_return(VCODE_INVALID_REG);

84✔

8177

         vcode_block_t main_bb = emit_block();

84✔

8178

         vcode_select_block(main_bb);

84✔

8180

         vcode_type_t vtime = vtype_time();

84✔

8182

         vcode_reg_t delay_reg;

84✔

8183

         if (tree_has_delay(wave))

84✔

8184

            delay_reg = lower_rvalue(lu, tree_delay(wave));

60✔

8186

            delay_reg = emit_const(vtime, 0);

24✔

8188

         vcode_reg_t reject_reg = emit_const(vtime, 0);

84✔

8189

         vcode_reg_t value_reg = lower_rvalue(lu, expr);

84✔

8191

         target_part_t parts[] = {

84✔

8193

              .reg = lower_signal_ref(lu, decl),

84✔

8202

         target_part_t *ptr = parts;

84✔

8203

         lower_signal_assign_target(lu, &ptr, decl, value_reg, type,

84✔

8206

         emit_return(VCODE_INVALID_REG);

84✔

8208

         unit_registry_finalise(parent->registry, lu);

84✔

8210

         vcode_state_restore(&state);

84✔

8212

         emit_process_init(name, lower_debug_locus(decl));

84✔

8214

      break;

84✔

8216

   case IMPLICIT_TRANSACTION:

18✔

8218

         vcode_state_t state;

18✔

8219

         vcode_state_save(&state);

18✔

8221

         object_t *obj = tree_to_object(decl);

18✔

8222

         ident_t qual = ident_prefix(parent->name, name, '.');

18✔

8223

         vcode_unit_t vu = emit_function(qual, obj, parent->vunit);

18✔

8224

         vcode_set_result(vtype);

18✔

8226

         vcode_type_t vcontext = vtype_context(parent->name);

18✔

8227

         emit_param(vcontext, vcontext, ident_new("context"));

18✔

8229

         vcode_reg_t preg = emit_param(vtype, vtype, ident_new("p"));

18✔

8231

         lower_unit_t *lu = lower_unit_new(parent->registry, parent,

18✔

8233

         unit_registry_put(parent->registry, lu);

18✔

8235

         emit_return(emit_not(preg));

18✔

8237

         unit_registry_finalise(parent->registry, lu);

18✔

8239

         vcode_state_restore(&state);

18✔

8241

         vcode_reg_t locus = lower_debug_locus(decl);

18✔

8243

         vcode_type_t voffset = vtype_offset();

18✔

8244

         vcode_reg_t one_reg = emit_const(voffset, 1);

18✔

8246

         vcode_reg_t delay_reg = emit_const(vtype_time(), TIME_HIGH);

18✔

8247

         vcode_reg_t kind_reg = emit_const(voffset, IMPLICIT_TRANSACTION);

18✔

8248

         vcode_reg_t context_reg = lower_context_for_call(parent, qual);

18✔

8249

         vcode_reg_t closure = emit_closure(qual, context_reg, vtype, vtype);

18✔

8251

         vcode_reg_t sig = emit_implicit_signal(vtype, one_reg, one_reg, locus,

18✔

8253

         emit_store(sig, var);

18✔

8255

         tree_t prefix = tree_value(decl);

18✔

8256

         type_t type = tree_type(prefix);

18✔

8258

         vcode_reg_t prefix_reg = lower_attr_prefix(parent, prefix);

18✔

8260

         if (type_is_homogeneous(type)) {

18✔

8261

            vcode_reg_t count_reg = lower_type_width(parent, type, prefix_reg);

15✔

8262

            vcode_reg_t nets_reg = lower_array_data(prefix_reg);

15✔

8264

            emit_map_implicit(nets_reg, sig, count_reg);

15✔

8267

            lower_for_each_field(parent, type, prefix_reg,

3✔

8269

                                 (void *)(intptr_t)sig);

3✔

8271

      break;

18✔

8273

   case IMPLICIT_STABLE:

36✔

8276

         tree_t w = tree_value(decl);

36✔

8277

         assert(tree_kind(w) == T_WAVEFORM);

36✔

8279

         tree_t prefix = tree_value(w);

36✔

8280

         ident_t qual = ident_prefix(parent->name, name, '.');

36✔

8283

            vcode_state_t state;

36✔

8284

            vcode_state_save(&state);

36✔

8286

            object_t *obj = tree_to_object(prefix);

36✔

8287

            vcode_unit_t vu = emit_function(qual, obj, parent->vunit);

36✔

8288

            vcode_set_result(vtype);

36✔

8290

            vcode_type_t vcontext = vtype_context(parent->name);

36✔

8291

            emit_param(vcontext, vcontext, ident_new("context"));

36✔

8293

            lower_unit_t *lu = lower_unit_new(parent->registry, parent,

36✔

8295

            unit_registry_put(parent->registry, lu);

36✔

8297

            lower_signal_flag_fn_t fn =

72✔

8298

               kind == IMPLICIT_STABLE ? emit_event_flag : emit_active_flag;

36✔

8299

            vcode_reg_t flag_reg = lower_signal_flag(lu, prefix, fn);

36✔

8301

            emit_return(emit_not(flag_reg));

36✔

8303

            unit_registry_finalise(parent->registry, lu);

36✔

8305

            vcode_state_restore(&state);

36✔

8308

         vcode_reg_t delay_reg;

36✔

8309

         if (tree_has_delay(w))

36✔

8310

            delay_reg = lower_rvalue(parent, tree_delay(w));

21✔

8312

            delay_reg = emit_const(vtype_time(), 0);

15✔

8314

         vcode_reg_t one_reg = emit_const(vtype_offset(), 1);

36✔

8315

         vcode_reg_t locus = lower_debug_locus(decl);

36✔

8316

         vcode_reg_t context_reg = lower_context_for_call(parent, qual);

36✔

8317

         vcode_reg_t closure = emit_closure(qual, context_reg, vtype, vtype);

36✔

8318

         vcode_reg_t kind_reg = emit_const(vtype_offset(), kind);

36✔

8319

         vcode_reg_t sig = emit_implicit_signal(vtype, one_reg, one_reg, locus,

36✔

8321

         emit_store(sig, var);

36✔

8323

         vcode_reg_t prefix_reg = lower_attr_prefix(parent, prefix);

36✔

8325

         type_t prefix_type = tree_type(prefix);

36✔

8326

         if (type_is_homogeneous(prefix_type)) {

36✔

8327

            vcode_reg_t count_reg =

33✔

8328

               lower_type_width(parent, prefix_type, prefix_reg);

33✔

8329

            vcode_reg_t nets_reg = lower_array_data(prefix_reg);

33✔

8331

            emit_map_implicit(nets_reg, sig, count_reg);

33✔

8334

            lower_for_each_field(parent, prefix_type, prefix_reg,

3✔

8336

                                 (void *)(intptr_t)sig);

3✔

8340

159✔

8342

static void lower_file_decl(lower_unit_t *lu, tree_t decl)

198✔

8344

   type_t type = tree_type(decl);

198✔

8345

   vcode_type_t vtype = lower_type(type);

198✔

8346

   vcode_var_t var = emit_var(vtype, vtype, tree_ident(decl), 0);

198✔

8347

   lower_put_vcode_obj(decl, var, lu);

198✔

8349

   emit_store(emit_null(vtype), var);

198✔

8351

   if (tree_has_value(decl)) {

198✔

8354

      tree_t value = tree_value(decl);

98✔

8356

      vcode_reg_t name_array = lower_rvalue(lu, tree_value(decl));

98✔

8357

      vcode_reg_t name_data  = lower_array_data(name_array);

98✔

8358

      vcode_reg_t name_len   = lower_array_len(lu, tree_type(value), 0,

98✔

8360

      vcode_reg_t file_ptr   = emit_index(var, VCODE_INVALID_REG);

98✔

8361

      vcode_reg_t mode       = lower_rvalue(lu, tree_file_mode(decl));

98✔

8363

      emit_file_open(file_ptr, name_data, name_len, mode, VCODE_INVALID_REG);

98✔

8365

198✔

8367

static vcode_type_t lower_alias_type(tree_t alias)

6,325✔

8369

   tree_t value = tree_value(alias);

6,325✔

8370

   const class_t class = class_of(value);

6,325✔

8372

   type_t type = tree_has_type(alias) ? tree_type(alias) : tree_type(value);

6,325✔

8374

   if (type_is_array(type)) {

6,325✔

8375

      vcode_type_t velem;

940✔

8376

      switch (class) {

940✔

8377

      case C_SIGNAL:

140✔

8378

         velem = lower_signal_type(type_elem_recur(type));

140✔

8379

         break;

140✔

8380

      case C_VARIABLE:

713✔

8382

         velem = lower_type(type_elem_recur(type));

713✔

8383

         break;

713✔

8388

      vcode_type_t vbounds = lower_bounds(type);

853✔

8389

      return vtype_uarray(dims_for_type(type), velem, vbounds);

853✔

8395

static void lower_alias_decl(lower_unit_t *lu, tree_t decl)

6,348✔

8397

   tree_t value = tree_value(decl);

6,348✔

8398

   if (tree_kind(value) == T_EXTERNAL_NAME) {

6,348✔

8400

      lower_external_name(lu, value);

39✔

8401

      return;

39✔

8404

   vcode_type_t vtype = lower_alias_type(decl);

6,309✔

8405

   if (vtype == VCODE_INVALID_TYPE)

6,309✔

8408

   type_t value_type = tree_type(value);

837✔

8409

   type_t type = tree_has_type(decl) ? tree_type(decl) : value_type;

837✔

8411

   vcode_reg_t value_reg;

837✔

8412

   vcode_var_flags_t flags = 0;

837✔

8413

   if (class_of(value) == C_SIGNAL) {

837✔

8414

      flags |= VAR_SIGNAL;

125✔

8415

      value_reg = lower_lvalue(lu, value);

125✔

8418

      value_reg = lower_rvalue(lu, value);

712✔

8420

   vcode_type_t vbounds = lower_bounds(type);

837✔

8421

   vcode_var_t var = emit_var(vtype, vbounds, tree_ident(decl), flags);

837✔

8422

   lower_put_vcode_obj(decl, var, lu);

837✔

8424

   if (type_is_array(type)) {

837✔

8425

      vcode_reg_t data_reg = lower_array_data(value_reg);

837✔

8426

      vcode_reg_t wrap_reg =

837✔

8427

         lower_var_constraints(lu, type, value_type, value_reg, data_reg);

837✔

8429

      vcode_reg_t locus = lower_debug_locus(decl);

837✔

8430

      lower_check_array_sizes(lu, type, value_type, wrap_reg, value_reg, locus);

837✔

8432

      emit_store(wrap_reg, var);

837✔

8438

static void lower_enum_image_helper(type_t type, vcode_reg_t preg)

88✔

8440

   const int nlits = type_enum_literals(type);

88✔

8441

   assert(nlits >= 1);

88✔

8443

   vcode_block_t *blocks LOCAL = xmalloc_array(nlits, sizeof(vcode_block_t));

176✔

8444

   vcode_reg_t *cases LOCAL = xmalloc_array(nlits, sizeof(vcode_reg_t));

176✔

8446

   vcode_type_t vtype = lower_type(type);

88✔

8448

   for (int i = 0; i < nlits; i++) {

2,226✔

8449

      cases[i]  = emit_const(vtype, i);

2,138✔

8450

      blocks[i] = emit_block();

2,138✔

8453

   emit_case(preg, blocks[0], cases, blocks, nlits);

88✔

8455

   for (int i = 0; i < nlits; i++) {

2,226✔

8458

      ident_t id = tree_ident(type_enum_literal(type, i));

2,138✔

8459

      if (ident_char(id, 0) != '\'')

2,138✔

8460

         id = ident_downcase(id);

714✔

8462

      vcode_select_block(blocks[i]);

2,138✔

8463

      vcode_reg_t str = lower_wrap_string(istr(id));

2,138✔

8464

      emit_return(str);

2,138✔

8466

88✔

8468

static void lower_physical_image_helper(lower_unit_t *lu, type_t type,

15✔

8471

   vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX);

15✔

8472

   vcode_type_t vchar = vtype_char();

15✔

8473

   vcode_type_t vstring = vtype_uarray(1, vchar, vchar);

15✔

8475

   vcode_reg_t cast_reg = emit_cast(vint64, vint64, preg);

15✔

8476

   ident_t conv_fn =

15✔

8477

      ident_new("NVC.TEXT_UTIL.INT_TO_STRING(21NVC.TEXT_UTIL.T_INT64)S");

15✔

8478

   vcode_reg_t conv_args[] = {

15✔

8479

      lower_context_for_call(lu, conv_fn),

15✔

8482

   vcode_reg_t num_reg = emit_fcall(conv_fn, vstring, vstring, conv_args, 2);

15✔

8484

   vcode_reg_t num_len = emit_uarray_len(num_reg, 0);

15✔

8486

   const char *unit0 = istr(ident_downcase(tree_ident(type_unit(type, 0))));

15✔

8488

   vcode_reg_t append_len = emit_const(vtype_offset(), strlen(unit0) + 1);

15✔

8489

   vcode_reg_t total_len = emit_add(num_len, append_len);

15✔

8491

   vcode_type_t ctype = vtype_char();

15✔

8492

   vcode_reg_t mem_reg = emit_alloc(ctype, ctype, total_len);

15✔

8493

   emit_copy(mem_reg, emit_unwrap(num_reg), num_len);

15✔

8495

   vcode_reg_t ptr0_reg = emit_array_ref(mem_reg, num_len);

15✔

8496

   emit_store_indirect(emit_const(ctype, ' '), ptr0_reg);

15✔

8498

   vcode_reg_t unit_reg = lower_wrap_string(unit0);

15✔

8499

   vcode_reg_t ptr1_reg =

15✔

8500

      emit_array_ref(ptr0_reg, emit_const(vtype_offset(), 1));

15✔

8501

   emit_copy(ptr1_reg, emit_unwrap(unit_reg),

15✔

8502

             emit_const(vtype_offset(), strlen(unit0)));

15✔

8504

   vcode_dim_t dims[] = {

15✔

8505

      { .left  = emit_const(vtype_offset(), 1),

15✔

8507

        .dir   = emit_const(vtype_bool(), RANGE_TO)

15✔

8510

   emit_return(emit_wrap(mem_reg, dims, 1));

15✔

8511

15✔

8513

static void lower_numeric_image_helper(lower_unit_t *lu, type_t type,

71✔

8516

   vcode_type_t vchar = vtype_char();

71✔

8517

   vcode_type_t vstring = vtype_uarray(1, vchar, vchar);

71✔

8519

   ident_t conv_fn;

71✔

8520

   vcode_reg_t arg_reg;

71✔

8522

   if (type_is_real(type)) {

71✔

8523

      arg_reg = preg;

10✔

8524

      conv_fn = ident_new("NVC.TEXT_UTIL.REAL_TO_STRING(R)S");

10✔

8527

      vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX);

61✔

8528

      arg_reg = emit_cast(vint64, vint64, preg);

61✔

8529

      conv_fn = ident_new(

61✔

8533

   vcode_reg_t conv_args[] = {

71✔

8534

      lower_context_for_call(lu, conv_fn),

71✔

8537

   vcode_reg_t str_reg = emit_fcall(conv_fn, vstring, vstring, conv_args, 2);

71✔

8538

   emit_return(str_reg);

71✔

8539

71✔

8541

static void lower_record_image_helper(lower_unit_t *lu, type_t type,

10✔

8543

10✔

8544

   const int nfields = type_fields(type);

10✔

8545

   vcode_reg_t regs[nfields];

10✔

8546

   vcode_reg_t lengths[nfields];

10✔

8548

   vcode_type_t ctype = vtype_char();

10✔

8549

   vcode_type_t strtype = vtype_uarray(1, ctype, ctype);

10✔

8550

   vcode_type_t voffset = vtype_offset();

10✔

8552

   vcode_reg_t sum_reg = emit_const(voffset, nfields + 1);

10✔

8554

   for (int i = 0; i < nfields; i++) {

40✔

8555

      type_t ftype = type_base_recur(tree_type(type_field(type, i)));

30✔

8556

      ident_t func = ident_prefix(type_ident(ftype), ident_new("image"), '$');

30✔

8558

      vcode_reg_t context_reg = lower_context_for_call(lu, func);

30✔

8559

      vcode_reg_t field_reg = emit_record_ref(preg, i);

30✔

8561

      if (type_is_scalar(ftype) || have_uarray_ptr(field_reg))

30✔

8562

         field_reg = emit_load_indirect(field_reg);

27✔

8564

      vcode_reg_t args[] = { context_reg, field_reg };

30✔

8565

      regs[i] = emit_fcall(func, strtype, strtype, args, 2);

30✔

8566

      lengths[i] = emit_uarray_len(regs[i], 0);

30✔

8568

      sum_reg = emit_add(sum_reg, lengths[i]);

30✔

8571

   vcode_reg_t mem_reg = emit_alloc(ctype, ctype, sum_reg);

10✔

8573

   vcode_reg_t lparen_reg = emit_array_ref(mem_reg, emit_const(voffset, 0));

10✔

8574

   emit_store_indirect(emit_const(ctype, '('), lparen_reg);

10✔

8576

   vcode_reg_t index_reg = emit_const(voffset, 1);

10✔

8577

   for (int i = 0; i < nfields; i++) {

40✔

8578

      if (i > 0) {

30✔

8579

         vcode_reg_t comma_reg = emit_array_ref(mem_reg, index_reg);

20✔

8580

         emit_store_indirect(emit_const(ctype, ','), comma_reg);

20✔

8581

         index_reg = emit_add(index_reg, emit_const(voffset, 1));

20✔

8584

      vcode_reg_t src_reg = emit_unwrap(regs[i]);

30✔

8585

      vcode_reg_t dest_reg = emit_array_ref(mem_reg, index_reg);

30✔

8586

      emit_copy(dest_reg, src_reg, lengths[i]);

30✔

8587

      index_reg = emit_add(index_reg, lengths[i]);

30✔

8590

   vcode_reg_t rparen_reg = emit_array_ref(mem_reg, index_reg);

10✔

8591

   emit_store_indirect(emit_const(ctype, ')'), rparen_reg);

10✔

8593

   vcode_dim_t dims[] = {

10✔

8594

      { .left  = emit_const(vtype_offset(), 1),

10✔

8596

        .dir   = emit_const(vtype_bool(), RANGE_TO)

10✔

8599

   emit_return(emit_wrap(mem_reg, dims, 1));

10✔

8600

10✔

8602

static void lower_array_image_helper(lower_unit_t *lu, type_t type,

19✔

8605

   vcode_type_t ctype = vtype_char();

19✔

8606

   vcode_type_t strtype = vtype_uarray(1, ctype, ctype);

19✔

8607

   vcode_type_t voffset = vtype_offset();

19✔

8608

   vcode_type_t fields[] = { vtype_pointer(ctype), voffset };

19✔

8609

   vcode_type_t rtype = vtype_named_record(ident_new("elem"), fields, 2);

19✔

8611

   vcode_reg_t length_reg = lower_array_len(lu, type, 0, preg);

19✔

8613

   vcode_reg_t elems_reg = emit_alloc(rtype, rtype, length_reg);

19✔

8614

   vcode_reg_t zero_reg = emit_const(voffset, 0);

19✔

8615

   vcode_reg_t one_reg = emit_const(voffset, 1);

19✔

8616

   vcode_reg_t data_reg = lower_array_data(preg);

19✔

8618

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

19✔

8619

   emit_store(zero_reg, i_var);

19✔

8621

   vcode_block_t loop1_bb = emit_block();

19✔

8622

   vcode_block_t alloc_bb = emit_block();

19✔

8624

   vcode_var_t sum_var = lower_temp_var(lu, "sum", voffset, voffset);

19✔

8625

   emit_store(emit_add(length_reg, one_reg), sum_var);

19✔

8627

   type_t elem = type_base_recur(type_elem(type));

19✔

8628

   ident_t func = ident_prefix(type_ident(elem), ident_new("image"), '$');

19✔

8630

   vcode_reg_t context_reg = lower_context_for_call(lu, func);

19✔

8632

   vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, length_reg, zero_reg);

19✔

8633

   emit_cond(null_reg, alloc_bb, loop1_bb);

19✔

8635

   vcode_select_block(loop1_bb);

19✔

8638

      vcode_reg_t i_reg = emit_load(i_var);

19✔

8639

      vcode_reg_t sum_reg = emit_load(sum_var);

19✔

8641

      vcode_reg_t elem_reg = emit_array_ref(data_reg, i_reg);

19✔

8642

      if (type_is_scalar(elem))

19✔

8643

         elem_reg = emit_load_indirect(elem_reg);

15✔

8645

      vcode_reg_t args[] = { context_reg, elem_reg };

19✔

8646

      vcode_reg_t str_reg = emit_fcall(func, strtype, strtype, args, 2);

19✔

8648

      vcode_reg_t edata_reg = emit_unwrap(str_reg);

19✔

8649

      vcode_reg_t elen_reg = emit_uarray_len(str_reg, 0);

19✔

8650

      emit_store(emit_add(sum_reg, elen_reg), sum_var);

19✔

8652

      vcode_reg_t rptr_reg = emit_array_ref(elems_reg, i_reg);

19✔

8653

      emit_store_indirect(edata_reg, emit_record_ref(rptr_reg, 0));

19✔

8654

      emit_store_indirect(elen_reg, emit_record_ref(rptr_reg, 1));

19✔

8656

      vcode_reg_t next_reg = emit_add(i_reg, one_reg);

19✔

8657

      emit_store(next_reg, i_var);

19✔

8659

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, length_reg);

19✔

8660

      emit_cond(done_reg, alloc_bb, loop1_bb);

19✔

8663

   vcode_select_block(alloc_bb);

19✔

8665

   vcode_reg_t sum_reg = emit_load(sum_var);

19✔

8666

   vcode_reg_t mem_reg = emit_alloc(ctype, ctype, sum_reg);

19✔

8668

   vcode_reg_t lparen_reg = emit_array_ref(mem_reg, zero_reg);

19✔

8669

   emit_store_indirect(emit_const(ctype, '('), lparen_reg);

19✔

8671

   vcode_block_t loop2_bb = emit_block();

19✔

8672

   vcode_block_t exit_bb = emit_block();

19✔

8674

   vcode_var_t index_var = lower_temp_var(lu, "index", voffset, voffset);

19✔

8675

   emit_store(zero_reg, i_var);

19✔

8676

   emit_store(one_reg, index_var);

19✔

8678

   emit_cond(null_reg, exit_bb, loop2_bb);

19✔

8680

   vcode_select_block(loop2_bb);

19✔

8683

      vcode_reg_t i_reg = emit_load(i_var);

19✔

8684

      vcode_reg_t index_reg = emit_load(index_var);

19✔

8686

      vcode_reg_t rptr_reg = emit_array_ref(elems_reg, i_reg);

19✔

8687

      vcode_reg_t edata_reg = emit_load_indirect(emit_record_ref(rptr_reg, 0));

19✔

8688

      vcode_reg_t elen_reg = emit_load_indirect(emit_record_ref(rptr_reg, 1));

19✔

8690

      vcode_reg_t dest_reg = emit_array_ref(mem_reg, index_reg);

19✔

8691

      emit_copy(dest_reg, edata_reg, elen_reg);

19✔

8693

      index_reg = emit_add(index_reg, elen_reg);

19✔

8694

      vcode_reg_t comma_reg = emit_array_ref(mem_reg, index_reg);

19✔

8695

      emit_store_indirect(emit_const(ctype, ','), comma_reg);

19✔

8697

      emit_store(emit_add(index_reg, one_reg), index_var);

19✔

8699

      vcode_reg_t next_reg = emit_add(i_reg, one_reg);

19✔

8700

      emit_store(next_reg, i_var);

19✔

8702

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, length_reg);

19✔

8703

      emit_cond(done_reg, exit_bb, loop2_bb);

19✔

8706

   vcode_select_block(exit_bb);

19✔

8708

   vcode_reg_t last_reg = emit_sub(sum_reg, one_reg);

19✔

8709

   vcode_reg_t rparen_reg = emit_array_ref(mem_reg, last_reg);

19✔

8710

   emit_store_indirect(emit_const(ctype, ')'), rparen_reg);

19✔

8712

   vcode_dim_t dims[] = {

19✔

8713

      { .left  = emit_const(voffset, 1),

19✔

8715

        .dir   = emit_const(vtype_bool(), RANGE_TO)

19✔

8718

   emit_return(emit_wrap(mem_reg, dims, 1));

19✔

8719

19✔

8721

static void lower_character_array_image_helper(lower_unit_t *lu, type_t type,

81✔

8724

   type_t elem = type_base_recur(type_elem(type));

81✔

8725

   vcode_type_t ctype = vtype_char();

81✔

8726

   vcode_type_t voffset = vtype_offset();

81✔

8728

   const int nlits = type_enum_literals(elem);

81✔

8729

   vcode_reg_t *map LOCAL = xmalloc_array(nlits, sizeof(vcode_reg_t));

162✔

8730

   for (int i = 0; i < nlits; i++) {

556✔

8731

      const ident_t id = tree_ident(type_enum_literal(elem, i));

475✔

8732

      assert(ident_char(id, 0) == '\'');

475✔

8733

      map[i] = emit_const(ctype, ident_char(id, 1));

475✔

8736

   vcode_type_t map_vtype = vtype_carray(nlits, ctype, ctype);

81✔

8737

   vcode_reg_t map_reg = emit_const_array(map_vtype, map, nlits);

81✔

8739

   vcode_reg_t zero_reg = emit_const(voffset, 0);

81✔

8740

   vcode_reg_t one_reg = emit_const(voffset, 1);

81✔

8741

   vcode_reg_t two_reg = emit_const(voffset, 2);

81✔

8743

   vcode_reg_t length_reg = lower_array_len(lu, type, 0, preg);

81✔

8744

   vcode_reg_t data_reg = lower_array_data(preg);

81✔

8745

   vcode_reg_t total_reg = quote ? emit_add(length_reg, two_reg) : length_reg;

81✔

8747

   vcode_reg_t mem_reg = emit_alloc(ctype, ctype, total_reg);

81✔

8749

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

81✔

8750

   emit_store(zero_reg, i_var);

81✔

8752

   if (quote) {

81✔

8753

      vcode_reg_t lquote_reg = emit_array_ref(mem_reg, zero_reg);

42✔

8754

      emit_store_indirect(emit_const(ctype, '"'), lquote_reg);

42✔

8757

   vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, length_reg, zero_reg);

81✔

8759

   vcode_block_t body_bb = emit_block();

81✔

8760

   vcode_block_t exit_bb = emit_block();

81✔

8762

   emit_cond(null_reg, exit_bb, body_bb);

81✔

8764

   vcode_select_block(body_bb);

81✔

8766

   vcode_reg_t i_reg    = emit_load(i_var);

81✔

8767

   vcode_reg_t sptr_reg = emit_array_ref(data_reg, i_reg);

81✔

8768

   vcode_reg_t src_reg  = emit_load_indirect(sptr_reg);

81✔

8769

   vcode_reg_t off_reg  = emit_cast(voffset, voffset, src_reg);

81✔

8770

   vcode_reg_t lptr_reg = emit_array_ref(emit_address_of(map_reg), off_reg);

81✔

8771

   vcode_reg_t doff_reg = quote ? emit_add(i_reg, one_reg) : i_reg;

81✔

8772

   vcode_reg_t dptr_reg = emit_array_ref(mem_reg, doff_reg);

81✔

8774

   emit_store_indirect(emit_load_indirect(lptr_reg), dptr_reg);

81✔

8776

   vcode_reg_t next_reg = emit_add(i_reg, one_reg);

81✔

8777

   vcode_reg_t cmp_reg  = emit_cmp(VCODE_CMP_EQ, next_reg, length_reg);

81✔

8778

   emit_store(next_reg, i_var);

81✔

8779

   emit_cond(cmp_reg, exit_bb, body_bb);

81✔

8781

   vcode_select_block(exit_bb);

81✔

8783

   if (quote) {

81✔

8784

      vcode_reg_t right_reg = emit_add(length_reg, one_reg);

42✔

8785

      vcode_reg_t rquote_reg = emit_array_ref(mem_reg, right_reg);

42✔

8786

      emit_store_indirect(emit_const(ctype, '"'), rquote_reg);

42✔

8789

   vcode_dim_t dims[] = {

81✔

8791

         .left  = emit_const(voffset, 1),

81✔

8793

         .dir   = emit_const(vtype_bool(), RANGE_TO)

81✔

8796

   emit_return(emit_wrap(mem_reg, dims, 1));

81✔

8797

81✔

8799

static void lower_image_helper(lower_unit_t *lu, object_t *obj)

245✔

8801

   tree_t decl = tree_from_object(obj);

245✔

8803

   type_t type = tree_type(decl);

245✔

8804

   assert(type_is_representable(type));

245✔

8806

   vcode_type_t ctype = vtype_char();

245✔

8807

   vcode_type_t strtype = vtype_uarray(1, ctype, ctype);

245✔

8808

   vcode_set_result(strtype);

245✔

8810

   vcode_type_t vcontext = vtype_context(lu->parent->name);

245✔

8811

   emit_param(vcontext, vcontext, ident_new("context"));

245✔

8813

   vcode_type_t ptype = lower_param_type(type, C_CONSTANT, PORT_IN);

245✔

8814

   vcode_reg_t preg = emit_param(ptype, lower_bounds(type), ident_new("VAL"));

245✔

8816

   switch (type_kind(type)) {

245✔

8817

   case T_ENUM:

88✔

8818

      lower_enum_image_helper(type, preg);

88✔

8819

      break;

88✔

8820

   case T_INTEGER:

71✔

8822

      lower_numeric_image_helper(lu, type, preg);

71✔

8823

      break;

71✔

8824

   case T_PHYSICAL:

15✔

8825

      lower_physical_image_helper(lu, type, preg);

15✔

8826

      break;

15✔

8827

   case T_RECORD:

10✔

8828

      lower_record_image_helper(lu, type, preg);

10✔

8829

      break;

10✔

8830

   case T_SUBTYPE:

11✔

8831

      assert(type_is_array(type));

11✔

8835

         type_t elem = type_elem(type);

61✔

8836

         if (type_is_enum(elem) && all_character_literals(elem))

61✔

8837

            lower_character_array_image_helper(lu, type, preg, true);

42✔

8839

            lower_array_image_helper(lu, type, preg);

19✔

8845

245✔

8847

static void lower_enum_value_helper(lower_unit_t *lu, type_t type,

65✔

8850

   const int nlits = type_enum_literals(type);

65✔

8851

   assert(nlits >= 1);

65✔

8853

   vcode_reg_t arg_len_reg  = emit_uarray_len(preg, 0);

65✔

8854

   vcode_reg_t arg_data_reg = emit_unwrap(preg);

65✔

8856

   vcode_type_t voffset = vtype_offset();

65✔

8857

   vcode_type_t vchar = vtype_char();

65✔

8858

   vcode_type_t vstring = vtype_uarray(1, vchar, vchar);

65✔

8860

   ident_t canon_fn = ident_new("NVC.TEXT_UTIL.CANON_VALUE(S)S");

65✔

8861

   vcode_reg_t canon_args[] = {

65✔

8862

      lower_context_for_call(lu, canon_fn),

65✔

8865

   vcode_reg_t canon_reg = emit_fcall(canon_fn, vstring, vchar,

65✔

8867

   vcode_reg_t canon_len_reg  = emit_uarray_len(canon_reg, 0);

65✔

8869

   size_t stride = 0;

65✔

8870

   vcode_reg_t *len_regs LOCAL = xmalloc_array(nlits, sizeof(vcode_reg_t));

130✔

8871

   for (int i = 0; i < nlits; i++) {

1,127✔

8872

      size_t len = ident_len(tree_ident(type_enum_literal(type, i)));

1,062✔

8873

      len_regs[i] = emit_const(voffset, len);

1,062✔

8874

      stride = MAX(stride, len);

1,062✔

8877

   vcode_type_t len_array_type = vtype_carray(nlits, voffset, voffset);

65✔

8878

   vcode_reg_t len_array_reg =

65✔

8879

      emit_const_array(len_array_type, len_regs, nlits);

65✔

8880

   vcode_reg_t len_array_ptr = emit_address_of(len_array_reg);

65✔

8882

   const size_t nchars = nlits * stride;

65✔

8883

   vcode_reg_t *char_regs LOCAL = xmalloc_array(nchars, sizeof(vcode_reg_t));

130✔

8884

   for (int i = 0; i < nlits; i++) {

1,127✔

8885

      const char *str = istr(tree_ident(type_enum_literal(type, i)));

1,062✔

8886

      size_t pos = 0;

1,062✔

8887

      for (const char *p = str; *p; p++, pos++)

5,258✔

8888

         char_regs[(i * stride) + pos] = emit_const(vchar, *p);

4,196✔

8889

      for (; pos < stride; pos++)

2,202✔

8890

         char_regs[(i * stride) + pos] = emit_const(vchar, 0);

1,140✔

8893

   vcode_type_t char_array_type = vtype_carray(nchars, vchar, vchar);

65✔

8894

   vcode_reg_t char_array_reg =

65✔

8895

      emit_const_array(char_array_type, char_regs, nchars);

65✔

8896

   vcode_reg_t char_array_ptr = emit_address_of(char_array_reg);

65✔

8898

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

65✔

8899

   emit_store(emit_const(voffset, 0), i_var);

65✔

8901

   vcode_block_t head_bb = emit_block();

65✔

8902

   vcode_block_t fail_bb = emit_block();

65✔

8903

   emit_jump(head_bb);

65✔

8905

   const loc_t *loc = vcode_last_loc();

65✔

8907

   vcode_select_block(head_bb);

65✔

8909

   vcode_reg_t i_reg = emit_load(i_var);

65✔

8911

   vcode_block_t memcmp_bb = emit_block();

65✔

8912

   vcode_block_t skip_bb   = emit_block();

65✔

8913

   vcode_block_t match_bb  = emit_block();

65✔

8915

   vcode_reg_t len_ptr = emit_array_ref(len_array_ptr, i_reg);

65✔

8916

   vcode_reg_t len_reg = emit_load_indirect(len_ptr);

65✔

8917

   vcode_reg_t len_eq  = emit_cmp(VCODE_CMP_EQ, len_reg, canon_len_reg);

65✔

8918

   emit_cond(len_eq, memcmp_bb, skip_bb);

65✔

8920

   vcode_select_block(memcmp_bb);

65✔

8921

   vcode_reg_t char_off = emit_mul(i_reg, emit_const(voffset, stride));

65✔

8922

   vcode_reg_t char_ptr = emit_array_ref(char_array_ptr, char_off);

65✔

8924

   vcode_dim_t dims[] = {

65✔

8925

      { .left  = emit_const(vtype_offset(), 1),

65✔

8927

        .dir   = emit_const(vtype_bool(), RANGE_TO)

65✔

8930

   vcode_reg_t str_reg = emit_wrap(char_ptr, dims, 1);

65✔

8932

   type_t std_string = std_type(NULL, STD_STRING);

65✔

8933

   ident_t func = lower_predef_func_name(std_string, "=");

65✔

8935

   vcode_type_t vbool = vtype_bool();

65✔

8936

   vcode_reg_t context_reg = lower_context_for_call(lu, func);

65✔

8937

   vcode_reg_t str_cmp_args[] = { context_reg, str_reg, canon_reg };

65✔

8938

   vcode_reg_t eq_reg = emit_fcall(func, vbool, vbool, str_cmp_args, 3);

65✔

8939

   emit_cond(eq_reg, match_bb, skip_bb);

65✔

8941

   vcode_select_block(skip_bb);

65✔

8943

   vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1));

65✔

8944

   emit_store(i_next, i_var);

65✔

8946

   vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next,

65✔

8948

   emit_cond(done_reg, fail_bb, head_bb);

65✔

8950

   vcode_select_block(fail_bb);

65✔

8951

   emit_debug_info(loc);

65✔

8953

   vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1);

65✔

8954

   vcode_reg_t failure_reg = emit_const(vseverity, SEVERITY_FAILURE);

65✔

8956

   vcode_reg_t const_str_reg =

65✔

8957

      lower_wrap_string("\" is not a valid enumeration value");

65✔

8958

   vcode_reg_t const_str_len = emit_uarray_len(const_str_reg, 0);

65✔

8959

   vcode_reg_t extra_len = emit_add(const_str_len, emit_const(voffset, 1));

65✔

8960

   vcode_reg_t msg_len = emit_add(arg_len_reg, extra_len);

65✔

8961

   vcode_reg_t mem_reg = emit_alloc(vchar, vchar, msg_len);

65✔

8963

   emit_store_indirect(emit_const(vchar, '\"'), mem_reg);

65✔

8965

   vcode_reg_t ptr1_reg = emit_array_ref(mem_reg, emit_const(voffset, 1));

65✔

8966

   emit_copy(ptr1_reg, arg_data_reg, arg_len_reg);

65✔

8968

   vcode_reg_t ptr2_reg = emit_array_ref(ptr1_reg, arg_len_reg);

65✔

8969

   emit_copy(ptr2_reg, emit_unwrap(const_str_reg), const_str_len);

65✔

8971

   vcode_type_t vtype = lower_type(type);

65✔

8972

   vcode_type_t vbounds = lower_bounds(type);

65✔

8974

   vcode_reg_t locus = lower_debug_locus(type_enum_literal(type, 0));

65✔

8975

   emit_report(mem_reg, msg_len, failure_reg, locus);

65✔

8976

   emit_return(emit_const(vtype, 0));

65✔

8978

   vcode_select_block(match_bb);

65✔

8980

   lower_check_scalar_bounds(lu, i_reg, type, decl, NULL);

65✔

8981

   emit_return(emit_cast(vtype, vbounds, i_reg));

65✔

8982

65✔

8984

static void lower_physical_value_helper(lower_unit_t *lu, type_t type,

7✔

8987

   vcode_reg_t arg_len_reg  = emit_uarray_len(preg, 0);

7✔

8988

   vcode_reg_t arg_data_reg = emit_unwrap(preg);

7✔

8990

   vcode_type_t voffset = vtype_offset();

7✔

8991

   vcode_type_t vchar = vtype_char();

7✔

8992

   vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX);

7✔

8993

   vcode_type_t vstring = vtype_uarray(1, vchar, vchar);

7✔

8995

   vcode_type_t vstdint = (standard() < STD_19)

7✔

8996

      ? vtype_int(INT32_MIN, INT32_MAX) : vtype_int(INT64_MIN, INT64_MAX);

7✔

8998

   vcode_var_t used_var = lower_temp_var(lu, "used", vstdint, vstdint);

7✔

8999

   vcode_reg_t used_ptr = emit_index(used_var, VCODE_INVALID_REG);

7✔

9001

   vcode_var_t int_var = lower_temp_var(lu, "int", vint64, vint64);

7✔

9002

   vcode_reg_t int_ptr = emit_index(int_var, VCODE_INVALID_REG);

7✔

9004

   ident_t conv_fn =

7✔

9005

      ident_new("NVC.TEXT_UTIL.STRING_TO_INT(S21NVC.TEXT_UTIL.T_INT64N)");

7✔

9006

   vcode_reg_t text_util_reg = lower_context_for_call(lu, conv_fn);

7✔

9007

   vcode_reg_t conv_args[] = {

7✔

9013

   emit_fcall(conv_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

7✔

9016

   vcode_reg_t int_reg = emit_load(int_var);

7✔

9017

   vcode_reg_t used_reg = emit_cast(voffset, voffset, emit_load(used_var));

7✔

9019

   vcode_reg_t tail_ptr = emit_array_ref(arg_data_reg, used_reg);

7✔

9020

   vcode_reg_t tail_len = emit_sub(arg_len_reg, used_reg);

7✔

9022

   vcode_reg_t one_reg = emit_const(vtype_offset(), 1);

7✔

9023

   vcode_reg_t to_reg = emit_const(vtype_bool(), RANGE_TO);

7✔

9025

   vcode_dim_t tail_dims[1] = {

7✔

9031

   vcode_reg_t tail_reg = emit_wrap(tail_ptr, tail_dims, 1);

7✔

9033

   ident_t canon_fn = ident_new("NVC.TEXT_UTIL.CANON_VALUE(S)S");

7✔

9034

   vcode_reg_t canon_args[] = {

7✔

9038

   vcode_reg_t canon_reg = emit_fcall(canon_fn, vstring, vchar,

7✔

9040

   vcode_reg_t canon_len_reg = emit_uarray_len(canon_reg, 0);

7✔

9042

   const int nunits = type_units(type);

7✔

9043

   assert(nunits >= 1);

7✔

9045

   size_t stride = 0;

7✔

9046

   vcode_reg_t *len_regs LOCAL = xmalloc_array(nunits, sizeof(vcode_reg_t));

14✔

9047

   vcode_reg_t *mul_regs LOCAL = xmalloc_array(nunits, sizeof(vcode_reg_t));

14✔

9048

   for (int i = 0; i < nunits; i++) {

48✔

9049

      tree_t unit = type_unit(type, i);

41✔

9050

      size_t len = ident_len(tree_ident(unit));

41✔

9051

      len_regs[i] = emit_const(voffset, len);

41✔

9052

      stride = MAX(stride, len);

41✔

9054

      vcode_reg_t value_reg = lower_rvalue(lu, tree_value(unit));

41✔

9055

      mul_regs[i] = emit_cast(vint64, vint64, value_reg);

41✔

9058

   vcode_type_t len_array_type = vtype_carray(nunits, voffset, voffset);

7✔

9059

   vcode_reg_t len_array_reg =

7✔

9060

      emit_const_array(len_array_type, len_regs, nunits);

7✔

9061

   vcode_reg_t len_array_ptr = emit_address_of(len_array_reg);

7✔

9063

   vcode_type_t mul_array_type = vtype_carray(nunits, vint64, vint64);

7✔

9064

   vcode_reg_t mul_array_reg =

7✔

9065

      emit_const_array(mul_array_type, mul_regs, nunits);

7✔

9066

   vcode_reg_t mul_array_ptr = emit_address_of(mul_array_reg);

7✔

9068

   const size_t nchars = nunits * stride;

7✔

9069

   vcode_reg_t *char_regs LOCAL = xmalloc_array(nchars, sizeof(vcode_reg_t));

14✔

9070

   for (int i = 0; i < nunits; i++) {

48✔

9071

      const char *str = istr(tree_ident(type_unit(type, i)));

41✔

9072

      size_t pos = 0;

41✔

9073

      for (const char *p = str; *p; p++, pos++)

146✔

9074

         char_regs[(i * stride) + pos] = emit_const(vchar, *p);

105✔

9075

      for (; pos < stride; pos++)

68✔

9076

         char_regs[(i * stride) + pos] = emit_const(vchar, 0);

27✔

9079

   vcode_type_t char_array_type = vtype_carray(nchars, vchar, vchar);

7✔

9080

   vcode_reg_t char_array_reg =

7✔

9081

      emit_const_array(char_array_type, char_regs, nchars);

7✔

9082

   vcode_reg_t char_array_ptr = emit_address_of(char_array_reg);

7✔

9084

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

7✔

9085

   emit_store(emit_const(voffset, 0), i_var);

7✔

9087

   vcode_block_t head_bb = emit_block();

7✔

9088

   vcode_block_t fail_bb = emit_block();

7✔

9089

   emit_jump(head_bb);

7✔

9091

   const loc_t *loc = vcode_last_loc();

7✔

9093

   vcode_select_block(head_bb);

7✔

9095

   vcode_reg_t i_reg = emit_load(i_var);

7✔

9097

   vcode_block_t memcmp_bb = emit_block();

7✔

9098

   vcode_block_t skip_bb   = emit_block();

7✔

9099

   vcode_block_t match_bb  = emit_block();

7✔

9101

   vcode_reg_t len_ptr = emit_array_ref(len_array_ptr, i_reg);

7✔

9102

   vcode_reg_t len_reg = emit_load_indirect(len_ptr);

7✔

9103

   vcode_reg_t len_eq  = emit_cmp(VCODE_CMP_EQ, len_reg, canon_len_reg);

7✔

9104

   emit_cond(len_eq, memcmp_bb, skip_bb);

7✔

9106

   vcode_select_block(memcmp_bb);

7✔

9107

   vcode_reg_t char_off = emit_mul(i_reg, emit_const(voffset, stride));

7✔

9108

   vcode_reg_t char_ptr = emit_array_ref(char_array_ptr, char_off);

7✔

9110

   vcode_dim_t dims[] = {

7✔

9116

   vcode_reg_t str_reg = emit_wrap(char_ptr, dims, 1);

7✔

9118

   type_t std_string = std_type(NULL, STD_STRING);

7✔

9119

   ident_t func = lower_predef_func_name(std_string, "=");

7✔

9121

   vcode_reg_t std_reg = emit_link_package(well_known(W_STD_STANDARD));

7✔

9122

   vcode_type_t vbool = vtype_bool();

7✔

9123

   vcode_reg_t str_cmp_args[] = { std_reg, str_reg, canon_reg };

7✔

9124

   vcode_reg_t eq_reg = emit_fcall(func, vbool, vbool, str_cmp_args, 3);

7✔

9125

   emit_cond(eq_reg, match_bb, skip_bb);

7✔

9127

   vcode_select_block(skip_bb);

7✔

9129

   vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1));

7✔

9130

   emit_store(i_next, i_var);

7✔

9132

   vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next,

7✔

9134

   emit_cond(done_reg, fail_bb, head_bb);

7✔

9136

   vcode_select_block(fail_bb);

7✔

9137

   emit_debug_info(loc);

7✔

9139

   vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1);

7✔

9140

   vcode_reg_t failure_reg = emit_const(vseverity, SEVERITY_FAILURE);

7✔

9142

   vcode_reg_t const_str_reg = lower_wrap_string("\" is not a valid unit name");

7✔

9143

   vcode_reg_t const_str_len = emit_uarray_len(const_str_reg, 0);

7✔

9144

   vcode_reg_t extra_len = emit_add(const_str_len, emit_const(voffset, 1));

7✔

9145

   vcode_reg_t msg_len = emit_add(tail_len, extra_len);

7✔

9146

   vcode_reg_t mem_reg = emit_alloc(vchar, vchar, msg_len);

7✔

9148

   emit_store_indirect(emit_const(vchar, '\"'), mem_reg);

7✔

9150

   vcode_reg_t ptr1_reg = emit_array_ref(mem_reg, emit_const(voffset, 1));

7✔

9151

   emit_copy(ptr1_reg, tail_ptr, tail_len);

7✔

9153

   vcode_reg_t ptr2_reg = emit_array_ref(ptr1_reg, tail_len);

7✔

9154

   emit_copy(ptr2_reg, emit_unwrap(const_str_reg), const_str_len);

7✔

9156

   vcode_type_t vtype = lower_type(type);

7✔

9157

   vcode_type_t vbounds = lower_bounds(type);

7✔

9159

   vcode_reg_t locus = lower_debug_locus(type_unit(type, 0));

7✔

9160

   emit_report(mem_reg, msg_len, failure_reg, locus);

7✔

9161

   emit_return(emit_const(vtype, 0));

7✔

9163

   vcode_select_block(match_bb);

7✔

9165

   vcode_reg_t mul_ptr = emit_array_ref(mul_array_ptr, i_reg);

7✔

9166

   vcode_reg_t mul_reg = emit_load_indirect(mul_ptr);

7✔

9167

   vcode_reg_t result_reg = emit_mul(int_reg, mul_reg);

7✔

9169

   lower_check_scalar_bounds(lu, result_reg, type, decl, NULL);

7✔

9170

   emit_return(emit_cast(vtype, vbounds, result_reg));

7✔

9171

7✔

9173

static void lower_numeric_value_helper(lower_unit_t *lu, type_t type,

49✔

9176

   vcode_reg_t result_reg;

49✔

9177

   if (type_is_real(type)) {

49✔

9178

      ident_t conv_fn = ident_new("NVC.TEXT_UTIL.STRING_TO_REAL(S)R");

13✔

9180

      vcode_reg_t text_util_reg = lower_context_for_call(lu, conv_fn);

13✔

9181

      vcode_reg_t conv_args[] = { text_util_reg, preg };

13✔

9183

      vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX);

13✔

9185

      result_reg = emit_fcall(conv_fn, vreal, vreal,

13✔

9189

      ident_t conv_fn =

36✔

9190

         ident_new("NVC.TEXT_UTIL.STRING_TO_INT(S)21NVC.TEXT_UTIL.T_INT64");

36✔

9192

      vcode_reg_t text_util_reg = lower_context_for_call(lu, conv_fn);

36✔

9193

      vcode_reg_t conv_args[] = { text_util_reg, preg };

36✔

9195

      vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX);

36✔

9197

      result_reg = emit_fcall(conv_fn, vint64, vint64,

36✔

9201

   vcode_type_t vtype = lower_type(type);

49✔

9202

   vcode_type_t vbounds = lower_bounds(type);

49✔

9204

   lower_check_scalar_bounds(lu, result_reg, type, decl, NULL);

49✔

9205

   emit_return(emit_cast(vtype, vbounds, result_reg));

49✔

9206

49✔

9208

static void lower_record_value_helper(lower_unit_t *lu, type_t type,

13✔

9211

   vcode_type_t voffset = vtype_offset();

13✔

9212

   vcode_type_t ctype = vtype_char();

13✔

9213

   vcode_type_t strtype = vtype_uarray(1, ctype, ctype);

13✔

9214

   vcode_type_t vtype = lower_type(type);

13✔

9215

   vcode_type_t vnat = vtype_int(0, INT64_MAX);

13✔

9217

   vcode_reg_t locus = lower_debug_locus(decl);

13✔

9219

   vcode_var_t result_var =

13✔

9220

      emit_var(vtype, vtype, ident_new("result"), VAR_HEAP);

13✔

9222

   ident_t find_open_fn = ident_new("NVC.TEXT_UTIL.FIND_OPEN(S)N");

13✔

9223

   ident_t find_close_fn = ident_new("NVC.TEXT_UTIL.FIND_CLOSE(SN)");

13✔

9224

   ident_t next_delim_fn = ident_new("NVC.TEXT_UTIL.NEXT_DELIMITER(SN)S");

13✔

9225

   vcode_reg_t text_util_reg = lower_context_for_call(lu, next_delim_fn);

13✔

9227

   vcode_reg_t open_args[] = { text_util_reg, preg };

13✔

9228

   vcode_reg_t open_reg = emit_fcall(find_open_fn, vnat, vnat, open_args, 2);

13✔

9230

   vcode_reg_t off_reg = emit_cast(voffset, voffset, open_reg);

13✔

9231

   vcode_reg_t ptr_reg = emit_index(result_var, VCODE_INVALID_REG);

13✔

9233

   const int nfields = type_fields(type);

13✔

9234

   for (int i = 0; i < nfields; i++) {

52✔

9235

      vcode_reg_t nd_args[] = { text_util_reg, preg, off_reg };

39✔

9236

      vcode_reg_t nd_reg = emit_fcall(next_delim_fn, strtype, ctype,

39✔

9239

      type_t ftype = type_base_recur(tree_type(type_field(type, i)));

39✔

9241

      ident_t func = ident_prefix(type_ident(ftype), ident_new("value"), '$');

39✔

9242

      vcode_reg_t args[] = {

39✔

9243

         lower_context_for_call(lu, func),

39✔

9247

      vcode_type_t fvtype = lower_func_result_type(ftype);

39✔

9248

      vcode_type_t fvbounds = lower_bounds(ftype);

39✔

9250

      vcode_reg_t value_reg = emit_fcall(func, fvtype, fvbounds, args, 2);

39✔

9252

      vcode_reg_t vlen_reg = emit_uarray_len(nd_reg, 0);

39✔

9253

      off_reg = emit_add(off_reg, vlen_reg);

39✔

9254

      off_reg = emit_add(off_reg, emit_const(voffset, 1));   // Skip comma

39✔

9256

      vcode_reg_t fptr_reg = emit_record_ref(ptr_reg, i);

39✔

9257

      if (type_is_array(ftype)) {

39✔

9258

         vcode_reg_t data_reg = lower_array_data(value_reg);

3✔

9259

         vcode_reg_t count_reg = lower_array_total_len(lu, ftype, value_reg);

3✔

9260

         emit_copy(fptr_reg, data_reg, count_reg);

3✔

9262

      else if (type_is_record(ftype))

36✔

9263

         lower_copy_record(lu, ftype, fptr_reg, value_reg, locus);

3✔

9265

         emit_store_indirect(value_reg, fptr_reg);

33✔

9268

   vcode_reg_t close_args[] = { text_util_reg, preg, off_reg };

13✔

9269

   emit_fcall(find_close_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

13✔

9272

   emit_return(ptr_reg);

13✔

9273

13✔

9275

static void lower_array_value_helper(lower_unit_t *lu, type_t type,

64✔

9278

   vcode_type_t voffset = vtype_offset();

64✔

9279

   vcode_type_t ctype = vtype_char();

64✔

9280

   vcode_type_t strtype = vtype_uarray(1, ctype, ctype);

64✔

9281

   vcode_type_t vnat = vtype_int(0, INT64_MAX);

64✔

9283

   vcode_reg_t locus = lower_debug_locus(decl);

64✔

9285

   vcode_reg_t zero_reg = emit_const(voffset, 0);

64✔

9286

   vcode_reg_t one_reg = emit_const(voffset, 1);

64✔

9288

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

64✔

9289

   emit_store(zero_reg, i_var);

64✔

9291

   ident_t next_delim_fn = ident_new("NVC.TEXT_UTIL.NEXT_DELIMITER(SN)S");

64✔

9292

   ident_t count_delim_fn = ident_new("NVC.TEXT_UTIL.COUNT_DELIMITERS(S)N");

64✔

9293

   ident_t trim_ws_fn = ident_new("NVC.TEXT_UTIL.TRIM_WS(SNN)");

64✔

9294

   ident_t find_open_fn = ident_new("NVC.TEXT_UTIL.FIND_OPEN(S)N");

64✔

9295

   ident_t find_close_fn = ident_new("NVC.TEXT_UTIL.FIND_CLOSE(SN)");

64✔

9296

   ident_t bad_char_fn = ident_new("NVC.TEXT_UTIL.REPORT_BAD_CHAR(SC)");

64✔

9297

   vcode_reg_t text_util_reg = lower_context_for_call(lu, next_delim_fn);

64✔

9299

   type_t elem = type_base_recur(type_elem_recur(type));

64✔

9300

   vcode_type_t velem = lower_type(elem);

64✔

9301

   vcode_type_t vbounds = lower_bounds(elem);

64✔

9303

   if (type_is_character_array(type)) {

64✔

9304

      vcode_block_t body_bb = emit_block();

47✔

9305

      vcode_block_t bad_bb = emit_block();

47✔

9306

      vcode_block_t good_bb = emit_block();

47✔

9307

      vcode_block_t exit_bb = emit_block();

47✔

9308

      vcode_block_t paren_bb = emit_block();

47✔

9310

      vcode_var_t first_var = emit_var(vnat, vnat, ident_new("first"), 0);

47✔

9311

      vcode_var_t last_var = emit_var(vnat, vnat, ident_new("last"), 0);

47✔

9313

      vcode_reg_t first_ptr = emit_index(first_var, VCODE_INVALID_REG);

47✔

9314

      vcode_reg_t last_ptr = emit_index(last_var, VCODE_INVALID_REG);

47✔

9316

      vcode_reg_t trim_args[] = { text_util_reg, preg, first_ptr, last_ptr };

47✔

9317

      emit_fcall(trim_ws_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

47✔

9320

      vcode_reg_t first_reg = emit_cast(voffset, voffset, emit_load(first_var));

47✔

9321

      vcode_reg_t last_reg = emit_cast(voffset, voffset, emit_load(last_var));

47✔

9323

      vcode_reg_t count_reg = emit_add(emit_sub(last_reg, first_reg), one_reg);

47✔

9324

      vcode_reg_t mem_reg = emit_alloc(velem, vbounds, count_reg);

47✔

9326

      vcode_var_t pos_var = lower_temp_var(lu, "pos", voffset, voffset);

47✔

9327

      emit_store(emit_cast(voffset, voffset, first_reg), pos_var);

47✔

9329

      const int nlits = type_enum_literals(elem);

47✔

9330

      vcode_reg_t entry_vtype = vtype_int(0, nlits);

47✔

9331

      vcode_reg_t map[256], def_reg = emit_const(entry_vtype, nlits);

47✔

9332

      for (int i = 0; i < 256; i++)

12,079✔

9333

         map[i] = def_reg;

12,032✔

9334

      for (int i = 0; i < nlits; i++) {

1,099✔

9335

         const ident_t id = tree_ident(type_enum_literal(elem, i));

1,052✔

9336

         if (ident_char(id, 0) == '\'')

1,052✔

9337

            map[(uint8_t)ident_char(id, 1)] = emit_const(entry_vtype, i);

855✔

9340

      vcode_type_t map_vtype = vtype_carray(256, entry_vtype, entry_vtype);

47✔

9341

      vcode_reg_t map_array_reg = emit_const_array(map_vtype, map, 256);

47✔

9342

      vcode_reg_t map_reg = emit_address_of(map_array_reg);

47✔

9344

      vcode_reg_t data_reg = lower_array_data(preg);

47✔

9346

      vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg);

47✔

9347

      emit_cond(null_reg, exit_bb, body_bb);

47✔

9349

      vcode_select_block(body_bb);

47✔

9351

      vcode_reg_t i_reg = emit_load(i_var);

47✔

9352

      vcode_reg_t pos_reg = emit_load(pos_var);

47✔

9353

      vcode_reg_t sptr_reg = emit_array_ref(data_reg, pos_reg);

47✔

9354

      vcode_reg_t dptr_reg = emit_array_ref(mem_reg, i_reg);

47✔

9355

      vcode_reg_t char_reg = emit_load_indirect(sptr_reg);

47✔

9356

      vcode_reg_t cast_reg = emit_cast(voffset, ctype, char_reg);

47✔

9357

      vcode_reg_t mptr_reg = emit_array_ref(map_reg, cast_reg);

47✔

9358

      vcode_reg_t entry_reg = emit_load_indirect(mptr_reg);

47✔

9360

      vcode_reg_t bad_reg = emit_cmp(VCODE_CMP_EQ, entry_reg, def_reg);

47✔

9361

      emit_cond(bad_reg, bad_bb, good_bb);

47✔

9363

      vcode_select_block(good_bb);

47✔

9365

      vcode_reg_t good_reg = emit_cast(velem, velem, entry_reg);

47✔

9366

      emit_store_indirect(good_reg, dptr_reg);

47✔

9368

      vcode_reg_t next_pos_reg = emit_add(pos_reg, one_reg);

47✔

9369

      emit_store(next_pos_reg, pos_var);

47✔

9371

      vcode_reg_t next_i_reg = emit_add(i_reg, one_reg);

47✔

9372

      emit_store(next_i_reg, i_var);

47✔

9374

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_i_reg, count_reg);

47✔

9375

      emit_cond(done_reg, exit_bb, body_bb);

47✔

9377

      vcode_select_block(bad_bb);

47✔

9379

      vcode_reg_t bad_char_args[] = { text_util_reg, preg, char_reg };

47✔

9380

      emit_fcall(bad_char_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

47✔

9383

      emit_unreachable(locus);

47✔

9385

      vcode_select_block(exit_bb);

47✔

9387

      vcode_dim_t dims[] = {

47✔

9388

         { .left  = emit_const(vtype_offset(), 1),

47✔

9390

           .dir   = emit_const(vtype_bool(), RANGE_TO)

47✔

9394

      vcode_reg_t wrap_reg = emit_wrap(mem_reg, dims, 1);

47✔

9395

      emit_return(wrap_reg);

47✔

9397

      vcode_select_block(paren_bb);

47✔

9399

      lower_release_temp(lu, pos_var);

47✔

9402

   vcode_block_t body_bb = emit_block();

64✔

9403

   vcode_block_t exit_bb = emit_block();

64✔

9405

   vcode_reg_t count_args[] = { text_util_reg, preg };

64✔

9406

   vcode_reg_t count_result_reg = emit_fcall(count_delim_fn, vnat, vnat,

64✔

9408

   vcode_reg_t count_reg = emit_cast(voffset, voffset, count_result_reg);

64✔

9410

   vcode_reg_t mem_reg = emit_alloc(velem, vbounds, count_reg);

64✔

9412

   vcode_reg_t open_args[] = { text_util_reg, preg };

64✔

9413

   vcode_reg_t open_reg = emit_fcall(find_open_fn, vnat, vnat, open_args, 2);

64✔

9415

   vcode_var_t pos_var = lower_temp_var(lu, "pos", voffset, voffset);

64✔

9416

   emit_store(emit_cast(voffset, voffset, open_reg), pos_var);

64✔

9418

   vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg);

64✔

9419

   emit_cond(null_reg, exit_bb, body_bb);

64✔

9421

   vcode_select_block(body_bb);

64✔

9423

   vcode_reg_t i_reg = emit_load(i_var);

64✔

9424

   vcode_reg_t pos_reg = emit_load(pos_var);

64✔

9426

   vcode_reg_t nd_args[] = { text_util_reg, preg, pos_reg };

64✔

9427

   vcode_reg_t nd_reg = emit_fcall(next_delim_fn, strtype, ctype, nd_args, 3);

64✔

9429

   ident_t func = ident_prefix(type_ident(elem), ident_new("value"), '$');

64✔

9430

   vcode_reg_t args[] = {

64✔

9431

      lower_context_for_call(lu, func),

64✔

9435

   vcode_reg_t value_reg = emit_fcall(func, lower_func_result_type(elem),

64✔

9437

   vcode_reg_t ptr_reg = emit_array_ref(mem_reg, i_reg);

64✔

9439

   if (type_is_record(elem))

64✔

9440

      lower_copy_record(lu, elem, ptr_reg, value_reg, locus);

7✔

9442

      emit_store_indirect(value_reg, ptr_reg);

57✔

9444

   vcode_reg_t next_i_reg = emit_add(i_reg, one_reg);

64✔

9445

   emit_store(next_i_reg, i_var);

64✔

9447

   vcode_reg_t vlen_reg = emit_add(emit_uarray_len(nd_reg, 0), one_reg);

64✔

9448

   vcode_reg_t next_pos_reg = emit_add(pos_reg, vlen_reg);

64✔

9449

   emit_store(next_pos_reg, pos_var);

64✔

9451

   vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_i_reg, count_reg);

64✔

9452

   emit_cond(done_reg, exit_bb, body_bb);

64✔

9454

   vcode_select_block(exit_bb);

64✔

9456

   vcode_reg_t close_args[] = { text_util_reg, preg, emit_load(pos_var) };

64✔

9457

   emit_fcall(find_close_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE,

64✔

9460

   vcode_dim_t dims[] = {

64✔

9461

      { .left  = emit_const(vtype_offset(), 1),

64✔

9463

        .dir   = emit_const(vtype_bool(), RANGE_TO)

64✔

9467

   vcode_reg_t wrap_reg = emit_wrap(mem_reg, dims, 1);

64✔

9468

   emit_return(wrap_reg);

64✔

9469

64✔

9471

static void lower_value_helper(lower_unit_t *lu, object_t *obj)

198✔

9473

   tree_t decl = tree_from_object(obj);

198✔

9475

   type_t type = type_base_recur(tree_type(decl));

198✔

9476

   assert(type_is_representable(type));

198✔

9478

   vcode_set_result(lower_func_result_type(type));

198✔

9480

   vcode_type_t vcontext = vtype_context(lu->parent->name);

198✔

9481

   emit_param(vcontext, vcontext, ident_new("context"));

198✔

9483

   vcode_type_t ctype = vtype_char();

198✔

9484

   vcode_type_t strtype = vtype_uarray(1, ctype, ctype);

198✔

9485

   vcode_reg_t preg = emit_param(strtype, strtype, ident_new("VAL"));

198✔

9487

   switch (type_kind(type)) {

198✔

9488

   case T_ENUM:

65✔

9489

      lower_enum_value_helper(lu, type, decl, preg);

65✔

9490

      break;

65✔

9491

   case T_INTEGER:

49✔

9493

      lower_numeric_value_helper(lu, type, decl, preg);

49✔

9494

      break;

49✔

9495

   case T_PHYSICAL:

7✔

9496

      lower_physical_value_helper(lu, type, decl, preg);

7✔

9497

      break;

7✔

9498

   case T_RECORD:

13✔

9499

      lower_record_value_helper(lu, type, decl, preg);

13✔

9500

      break;

13✔

9501

   case T_ARRAY:

64✔

9502

      lower_array_value_helper(lu, type, decl, preg);

64✔

9503

      break;

64✔

9507

198✔

9509

static void lower_resolved_record_fn(lower_unit_t *lu, object_t *obj,

321✔

9512

   tree_t decl = tree_from_object(obj);

321✔

9514

   type_t type = tree_type(decl);

321✔

9515

   assert(!type_is_homogeneous(type) && can_be_signal(type));

321✔

9517

   vcode_set_result(lower_func_result_type(type));

321✔

9519

   vcode_type_t vtype = lower_type(type);

321✔

9520

   vcode_type_t vbounds = lower_bounds(type);

321✔

9521

   vcode_type_t vatype = lower_param_type(type, C_SIGNAL, PORT_IN);

321✔

9523

   vcode_type_t vcontext = vtype_context(lu->parent->name);

321✔

9524

   emit_param(vcontext, vcontext, ident_new("context"));

321✔

9526

   vcode_reg_t p_reg = emit_param(vatype, vbounds, ident_new("p"));

321✔

9528

   vcode_var_t var = emit_var(vtype, vbounds, ident_new("result"), 0);

321✔

9530

   vcode_reg_t data_reg, result_reg;

321✔

9531

   if (vtype_kind(vtype) == VCODE_TYPE_UARRAY) {

321✔

9532

      type_t elem = type_elem_recur(type);

85✔

9533

      vcode_reg_t count_reg = lower_array_total_len(lu, type, p_reg);

85✔

9534

      data_reg = emit_alloc(lower_type(elem), lower_bounds(elem),

85✔

9537

      result_reg = lower_rewrap(data_reg, p_reg);

85✔

9538

      emit_store(result_reg, var);

85✔

9541

      data_reg = result_reg = emit_index(var, VCODE_INVALID_VAR);

236✔

9543

   lower_for_each_field_2(lu, type, type, p_reg, data_reg, VCODE_INVALID_REG,

321✔

9545

   emit_return(result_reg);

321✔

9546

321✔

9548

static void lower_resolved_helper(lower_unit_t *lu, object_t *obj)

283✔

9550

   lower_resolved_record_fn(lu, obj, emit_resolved);

283✔

9551

283✔

9553

static void lower_last_value_helper(lower_unit_t *lu, object_t *obj)

19✔

9555

   lower_resolved_record_fn(lu, obj, emit_last_value);

19✔

9556

19✔

9558

static void lower_driving_value_helper(lower_unit_t *lu, object_t *obj)

19✔

9560

   lower_resolved_record_fn(lu, obj, emit_driving_value);

19✔

9561

19✔

9563

static void lower_last_time_field_cb(lower_unit_t *lu, tree_t field,

96✔

9567

   last_time_params_t *params = ctx;

96✔

9568

   vcode_reg_t last_reg = VCODE_INVALID_REG;

96✔

9570

   type_t ftype = tree_type(field);

96✔

9571

   if (type_is_homogeneous(ftype)) {

96✔

9572

      vcode_reg_t field_reg = emit_load_indirect(field_ptr);

84✔

9574

      if (type_is_array(ftype)) {

84✔

9580

         last_reg = (*params->fn)(field_reg, VCODE_INVALID_REG);

84✔

9583

      ident_t base_id = type_ident(type_base_recur(ftype));

12✔

9584

      ident_t helper_func =

12✔

9585

         ident_sprintf("%s$%s", istr(base_id), params->suffix);

12✔

9587

      vcode_reg_t arg_reg = field_ptr;

12✔

9588

      if (type_is_array(ftype)

12✔

9589

          && vcode_reg_kind(arg_reg) != VCODE_TYPE_UARRAY)

6✔

9590

         arg_reg = lower_wrap(lu, ftype, field_ptr);

6✔

9592

      vcode_type_t vtime = vtype_time();

12✔

9593

      vcode_reg_t context_reg = lower_context_for_call(lu, helper_func);

12✔

9594

      vcode_reg_t args[] = { context_reg, arg_reg };

12✔

9595

      last_reg = emit_fcall(helper_func, vtime, vtime, args, 2);

12✔

9598

   vcode_reg_t cur_reg = emit_load(params->var);

96✔

9599

   vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_LT, last_reg, cur_reg);

96✔

9600

   vcode_reg_t new_reg = emit_select(cmp_reg, last_reg, cur_reg);

96✔

9601

   emit_store(new_reg, params->var);

96✔

9602

96✔

9604

static void lower_last_time_fn(lower_unit_t *lu, object_t *obj,

44✔

9607

   tree_t decl = tree_from_object(obj);

44✔

9609

   type_t type = tree_type(decl);

44✔

9610

   assert(!type_is_homogeneous(type) && can_be_signal(type));

44✔

9612

   vcode_type_t vtime = vtype_time();

44✔

9613

   vcode_type_t vatype = lower_param_type(type, C_SIGNAL, PORT_IN);

44✔

9614

   vcode_type_t vbounds = lower_bounds(type);

44✔

9616

   vcode_set_result(vtime);

44✔

9618

   vcode_type_t vcontext = vtype_context(lu->parent->name);

44✔

9619

   emit_param(vcontext, vcontext, ident_new("context"));

44✔

9621

   vcode_reg_t p_reg = emit_param(vatype, vbounds, ident_new("p"));

44✔

9623

   vcode_var_t var = emit_var(vtime, vtime, ident_new("result"), 0);

44✔

9624

   emit_store(emit_const(vtime, TIME_HIGH), var);

44✔

9626

   last_time_params_t params = { fn, suffix, var };

44✔

9627

   lower_for_each_field(lu, type, p_reg, VCODE_INVALID_REG,

44✔

9630

   emit_return(emit_load(var));

44✔

9631

44✔

9633

static void lower_last_event_helper(lower_unit_t *lu, object_t *obj)

22✔

9635

   lower_last_time_fn(lu, obj, emit_last_event, "last_event");

22✔

9636

22✔

9638

static void lower_last_active_helper(lower_unit_t *lu, object_t *obj)

22✔

9640

   lower_last_time_fn(lu, obj, emit_last_active, "last_active");

22✔

9641

22✔

9643

static void lower_copy_helper(lower_unit_t *lu, object_t *obj)

46✔

9645

   tree_t decl = tree_from_object(obj);

46✔

9647

   type_t type = tree_type(decl);

46✔

9648

   assert(!lower_trivially_copyable(type));

46✔

9650

   vcode_type_t vbounds = lower_bounds(type);

46✔

9651

   vcode_type_t vdtype = lower_param_type(type, C_VARIABLE, PORT_OUT);

46✔

9652

   vcode_type_t vstype = lower_param_type(type, C_VARIABLE, PORT_IN);

46✔

9653

   vcode_type_t vlocus = vtype_debug_locus();

46✔

9654

   vcode_type_t vcontext = vtype_context(lu->parent->name);

46✔

9655

   emit_param(vcontext, vcontext, ident_new("context"));

46✔

9657

   vcode_reg_t pdst_reg = emit_param(vdtype, vbounds, ident_new("dest"));

46✔

9658

   vcode_reg_t psrc_reg = emit_param(vstype, vbounds, ident_new("src"));

46✔

9659

   vcode_reg_t plocus = emit_param(vlocus, vlocus, ident_new("locus"));

46✔

9661

   if (type_is_record(type)) {

46✔

9662

      const int nfields = type_fields(type);

40✔

9663

      for (int i = 0; i < nfields; i++) {

107✔

9664

         type_t ftype = tree_type(type_field(type, i));

67✔

9666

         vcode_reg_t dst_ptr = emit_record_ref(pdst_reg, i);

67✔

9667

         vcode_reg_t src_ptr = emit_record_ref(psrc_reg, i);

67✔

9669

         if (type_is_scalar(ftype) || type_is_access(ftype)) {

82✔

9670

            vcode_reg_t src_reg = emit_load_indirect(src_ptr);

15✔

9671

            emit_store_indirect(src_reg, dst_ptr);

15✔

9673

         else if (type_is_array(ftype)) {

52✔

9674

            vcode_reg_t src_reg = src_ptr;

46✔

9675

            if (have_uarray_ptr(src_reg))

46✔

9676

               src_reg = emit_load_indirect(src_ptr);

46✔

9678

            vcode_reg_t dst_reg = dst_ptr;

46✔

9679

            if (have_uarray_ptr(dst_reg))

46✔

9680

               dst_reg = emit_load_indirect(dst_ptr);

46✔

9682

            lower_copy_array(lu, ftype, ftype, dst_reg, src_reg, plocus);

46✔

9684

         else if (type_is_record(ftype))

6✔

9685

            lower_copy_record(lu, ftype, dst_ptr, src_ptr, plocus);

6✔

9692

      assert(type_is_array(type));

6✔

9694

      type_t elem = type_elem_recur(type);

6✔

9695

      lower_check_array_sizes(lu, type, type, pdst_reg, psrc_reg, plocus);

6✔

9697

      vcode_reg_t count_reg = lower_array_total_len(lu, type, psrc_reg);

6✔

9699

      vcode_reg_t src_data = lower_array_data(psrc_reg);

6✔

9700

      vcode_reg_t dst_data = lower_array_data(pdst_reg);

6✔

9702

      assert(!lower_trivially_copyable(elem));

6✔

9704

      vcode_type_t voffset = vtype_offset();

6✔

9706

      vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

6✔

9707

      vcode_reg_t zero_reg = emit_const(voffset, 0);

6✔

9708

      emit_store(zero_reg, i_var);

6✔

9710

      vcode_block_t body_bb = emit_block();

6✔

9711

      vcode_block_t exit_bb = emit_block();

6✔

9713

      vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg);

6✔

9714

      emit_cond(null_reg, exit_bb, body_bb);

6✔

9716

      vcode_select_block(body_bb);

6✔

9718

      vcode_reg_t i_reg = emit_load(i_var);

6✔

9719

      vcode_reg_t dptr_reg = emit_array_ref(dst_data, i_reg);

6✔

9720

      vcode_reg_t sptr_reg = emit_array_ref(src_data, i_reg);

6✔

9722

      lower_copy_record(lu, elem, dptr_reg, sptr_reg, plocus);

6✔

9724

      vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1));

6✔

9725

      emit_store(next_reg, i_var);

6✔

9727

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count_reg);

6✔

9728

      emit_cond(done_reg, exit_bb, body_bb);

6✔

9730

      vcode_select_block(exit_bb);

6✔

9732

      lower_release_temp(lu, i_var);

6✔

9735

   emit_return(VCODE_INVALID_REG);

46✔

9736

46✔

9738

static void lower_new_helper(lower_unit_t *lu, object_t *obj)

36✔

9740

   tree_t decl = tree_from_object(obj);

36✔

9742

   type_t type = tree_type(decl);

36✔

9743

   assert(type_is_record(type) && !type_const_bounds(type));

36✔

9745

   vcode_type_t vbounds = lower_bounds(type);

36✔

9746

   vcode_type_t vdtype = lower_param_type(type, C_VARIABLE, PORT_OUT);

36✔

9747

   vcode_type_t vstype = lower_param_type(type, C_VARIABLE, PORT_IN);

36✔

9748

   vcode_type_t vcontext = vtype_context(lu->parent->name);

36✔

9749

   emit_param(vcontext, vcontext, ident_new("context"));

36✔

9751

   vcode_reg_t pdst_reg = emit_param(vdtype, vbounds, ident_new("dest"));

36✔

9752

   vcode_reg_t psrc_reg = emit_param(vstype, vbounds, ident_new("src"));

36✔

9754

   const int nfields = type_fields(type);

36✔

9755

   for (int i = 0; i < nfields; i++) {

96✔

9756

      type_t ftype = tree_type(type_field(type, i));

60✔

9758

      vcode_reg_t dst_ptr = emit_record_ref(pdst_reg, i);

60✔

9759

      vcode_reg_t src_ptr = emit_record_ref(psrc_reg, i);

60✔

9761

      if (type_is_scalar(ftype) || type_is_access(ftype)) {

81✔

9762

         vcode_reg_t src_reg = emit_load_indirect(src_ptr);

21✔

9763

         emit_store_indirect(src_reg, dst_ptr);

21✔

9765

      else if (type_is_array(ftype)) {

39✔

9766

         vcode_reg_t src_reg = src_ptr;

36✔

9767

         if (have_uarray_ptr(src_reg))

36✔

9768

            src_reg = emit_load_indirect(src_ptr);

36✔

9770

         vcode_reg_t count_reg = lower_array_total_len(lu, ftype, src_reg);

36✔

9771

         vcode_reg_t dst_reg = dst_ptr;

36✔

9773

         if (have_uarray_ptr(dst_reg)) {

36✔

9774

            type_t scalar_elem = type_elem_recur(ftype);

36✔

9775

            vcode_type_t vtype = lower_type(scalar_elem);

36✔

9776

            vcode_reg_t mem_reg = emit_new(vtype, count_reg);

36✔

9777

            vcode_reg_t all_reg = emit_all(mem_reg);

36✔

9778

            vcode_reg_t wrap_reg = lower_rewrap(all_reg, src_reg);

36✔

9780

            emit_store_indirect(wrap_reg, dst_ptr);

36✔

9781

            dst_reg = wrap_reg;

36✔

9784

         vcode_reg_t src_data = lower_array_data(src_reg);

36✔

9785

         vcode_reg_t dst_data = lower_array_data(dst_reg);

36✔

9786

         emit_copy(dst_data, src_data, count_reg);

36✔

9788

      else if (type_is_record(ftype))

3✔

9789

         lower_new_record(lu, ftype, dst_ptr, src_ptr);

3✔

9794

   emit_return(VCODE_INVALID_REG);

36✔

9795

36✔

9797

static void lower_instantiated_package(lower_unit_t *parent, tree_t decl)

183✔

9799

   vcode_state_t state;

183✔

9800

   vcode_state_save(&state);

183✔

9802

   vcode_select_unit(parent->vunit);

183✔

9804

   ident_t context_id = vcode_unit_name(parent->vunit);

183✔

9805

   ident_t name = ident_prefix(context_id, tree_ident(decl), '.');

183✔

9807

   vcode_unit_t vu = emit_package(name, tree_to_object(decl), parent->vunit);

183✔

9809

   lower_unit_t *lu = lower_unit_new(parent->registry, parent,

183✔

9811

   unit_registry_put(parent->registry, lu);

183✔

9813

   lu->cscope = cover_create_scope(lu->cover, parent->cscope, decl, NULL);

183✔

9815

   lower_generics(lu, decl, NULL);

183✔

9816

   lower_decls(lu, decl);

183✔

9818

   emit_return(VCODE_INVALID_REG);

183✔

9820

   unit_registry_finalise(parent->registry, lu);

183✔

9822

   vcode_state_restore(&state);

183✔

9824

   vcode_type_t vcontext = vtype_context(name);

183✔

9825

   vcode_var_t var = emit_var(vcontext, vcontext, name, 0);

183✔

9826

   lower_put_vcode_obj(decl, var, parent);

183✔

9828

   vcode_reg_t pkg_reg = emit_package_init(name, emit_context_upref(0));

183✔

9829

   emit_store(pkg_reg, var);

183✔

9831

   const int ngenerics = tree_generics(tree_ref(decl));

183✔

9832

   for (int i = 0; i < ngenerics; i++)

752✔

9833

      lower_put_vcode_obj(tree_generic(decl, i), var | INSTANCE_BIT, parent);

569✔

9835

   const int ndecls = tree_decls(tree_ref(decl));

183✔

9836

   for (int i = 0; i < ndecls; i++)

589✔

9837

      lower_put_vcode_obj(tree_decl(decl, i), var | INSTANCE_BIT, parent);

406✔

9838

183✔

9840

static void lower_type_bounds_var(lower_unit_t *lu, type_t type)

284✔

9842

   if (type_is_array(type)) {

284✔

9843

      vcode_type_t vtype = lower_type(type);

161✔

9844

      assert(vtype_kind(vtype) == VCODE_TYPE_UARRAY);

161✔

9846

      type_t elem = type_elem_recur(type);

161✔

9847

      vcode_type_t velem = lower_type(elem);

161✔

9848

      vcode_type_t vbounds = lower_bounds(elem);

161✔

9850

      vcode_var_t var = emit_var(vtype, vbounds, type_ident(type), VAR_CONST);

161✔

9852

      vcode_reg_t null_reg = emit_null(vtype_pointer(velem));

161✔

9853

      vcode_reg_t wrap_reg = lower_wrap(lu, type, null_reg);

161✔

9854

      emit_store(wrap_reg, var);

161✔

9856

      lower_put_vcode_obj(type, var, lu);

161✔

9858

   else if (type_is_scalar(type)) {

123✔

9859

      vcode_type_t velem = lower_type(type);

31✔

9860

      vcode_type_t vbounds = lower_bounds(type);

31✔

9862

      vcode_type_t vtype = vtype_uarray(1, velem, vbounds);

31✔

9864

      vcode_var_t var = emit_var(vtype, vbounds, type_ident(type), VAR_CONST);

31✔

9866

      tree_t r = range_of(type, 0);

31✔

9867

      vcode_reg_t left_reg = lower_range_left(lu, r);

31✔

9868

      vcode_reg_t right_reg = lower_range_right(lu, r);

31✔

9869

      vcode_reg_t dir_reg = lower_range_dir(lu, r);

31✔

9871

      vcode_dim_t dims[1] = {

31✔

9875

      vcode_reg_t null_reg = emit_null(vtype_pointer(velem));

31✔

9876

      vcode_reg_t wrap_reg = emit_wrap(null_reg, dims, 1);

31✔

9877

      emit_store(wrap_reg, var);

31✔

9879

      lower_put_vcode_obj(type, var, lu);

31✔

9881

   else if (type_is_record(type)) {

92✔

9882

      vcode_type_t vtype = lower_type(type);

92✔

9883

      assert(vtype_kind(vtype) == VCODE_TYPE_RECORD);

92✔

9885

      vcode_var_t var = emit_var(vtype, vtype, type_ident(type), VAR_CONST);

92✔

9887

      vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG);

92✔

9888

      vcode_reg_t value_reg = lower_default_value(lu, type, ptr_reg);

92✔

9889

      lower_copy_record(lu, type, ptr_reg, value_reg, VCODE_INVALID_REG);

92✔

9891

      lower_put_vcode_obj(type, var, lu);

92✔

9895

284✔

9897

static void lower_foreign_stub(lower_unit_t *lu, object_t *obj)

141✔

9899

   tree_t spec = tree_from_object(obj);

141✔

9900

   assert(tree_kind(spec) == T_ATTR_SPEC);

141✔

9902

   tree_t value = tree_value(spec);

141✔

9903

   type_t str_type = tree_type(value);

141✔

9905

   tree_t sub = tree_ref(spec);

141✔

9906

   assert(is_subprogram(sub));

141✔

9908

   type_t type = tree_type(sub);

141✔

9909

   if (type_has_result(type))

141✔

9910

      vcode_set_result(lower_func_result_type(type_result(type)));

90✔

9912

   vcode_type_t vcontext = vtype_context(lu->parent->name);

141✔

9913

   emit_param(vcontext, vcontext, ident_new("context"));

141✔

9915

   lower_subprogram_ports(lu, sub, false);

141✔

9917

   vcode_reg_t spec_reg = lower_rvalue(lu, value);

141✔

9918

   vcode_reg_t data_reg = lower_array_data(spec_reg);

141✔

9919

   vcode_reg_t length_reg = lower_array_len(lu, str_type, 0, spec_reg);

141✔

9920

   vcode_reg_t locus = lower_debug_locus(spec);

141✔

9922

   emit_bind_foreign(data_reg, length_reg, locus);

141✔

9923

   emit_unreachable(VCODE_INVALID_REG);

141✔

9924

141✔

9926

static void lower_decl(lower_unit_t *lu, tree_t decl)

56,365✔

9928

   PUSH_DEBUG_INFO(decl);

112,730✔

9930

   switch (tree_kind(decl)) {

56,365✔

9931

   case T_CONST_DECL:

15,588✔

9933

      lower_var_decl(lu, decl);

15,588✔

9934

      break;

15,588✔

9936

   case T_SIGNAL_DECL:

6,749✔

9937

      lower_signal_decl(lu, decl);

6,749✔

9938

      break;

6,749✔

9940

   case T_IMPLICIT_SIGNAL:

159✔

9941

      lower_implicit_decl(lu, decl);

159✔

9942

      break;

159✔

9944

   case T_FILE_DECL:

198✔

9945

      lower_file_decl(lu, decl);

198✔

9946

      break;

198✔

9948

   case T_ALIAS:

6,348✔

9949

      lower_alias_decl(lu, decl);

6,348✔

9950

      break;

6,348✔

9952

   case T_TYPE_DECL:

11,721✔

9954

         type_t type = tree_type(decl);

11,721✔

9955

         ident_t id = type_ident(type);

11,721✔

9956

         object_t *obj = tree_to_object(decl);

11,721✔

9958

         if (needs_bounds_var(type))

11,721✔

9959

            lower_type_bounds_var(lu, type);

102✔

9961

         if (type_is_representable(type)) {

11,721✔

9962

            ident_t image = ident_prefix(id, ident_new("image"), '$');

7,241✔

9963

            unit_registry_defer(lu->registry, image, lu, emit_function,

7,241✔

9966

            ident_t value = ident_prefix(id, ident_new("value"), '$');

7,241✔

9967

            unit_registry_defer(lu->registry, value, lu, emit_function,

7,241✔

9971

         if (!type_is_homogeneous(type) && can_be_signal(type)) {

11,721✔

9972

            ident_t resolved = ident_prefix(id, ident_new("resolved"), '$');

1,498✔

9973

            unit_registry_defer(lu->registry, resolved, lu, emit_function,

1,498✔

9976

            ident_t last_value = ident_prefix(id, ident_new("last_value"), '$');

1,498✔

9977

            unit_registry_defer(lu->registry, last_value, lu, emit_function,

1,498✔

9980

            ident_t last_event = ident_sprintf("%s$last_event", istr(id));

1,498✔

9981

            unit_registry_defer(lu->registry, last_event, lu, emit_function,

1,498✔

9984

            ident_t last_active = ident_sprintf("%s$last_active", istr(id));

1,498✔

9985

            unit_registry_defer(lu->registry, last_active, lu, emit_function,

1,498✔

9988

            ident_t driving = ident_prefix(id, ident_new("driving"), '$');

1,498✔

9989

            unit_registry_defer(lu->registry, driving, lu, emit_function,

1,498✔

9993

         if (!lower_trivially_copyable(type)) {

11,721✔

9994

            ident_t copy = ident_prefix(id, ident_new("copy"), '$');

351✔

9995

            unit_registry_defer(lu->registry, copy, lu, emit_function,

351✔

9999

         if (type_is_record(type) && !type_const_bounds(type)) {

11,721✔

10000

            ident_t new = ident_prefix(id, ident_new("new"), '$');

295✔

10001

            unit_registry_defer(lu->registry, new, lu, emit_function,

295✔

10007

   case T_SUBTYPE_DECL:

3,023✔

10009

         type_t type = tree_type(decl);

3,023✔

10010

         if (needs_bounds_var(type))

3,023✔

10011

            lower_type_bounds_var(lu, type);

182✔

10029

   case T_PACKAGE:

195✔

10032

      if (unit_needs_cgen(decl))

195✔

10033

         lower_instantiated_package(lu, decl);

183✔

10036

   case T_PSL_DECL:

72✔

10037

      psl_lower_decl(lu->registry, lu, tree_psl(decl), tree_ident(decl));

72✔

10038

      break;

72✔

10043

56,365✔

10045

void lower_finished(lower_unit_t *lu, vcode_unit_t shape)

44,873✔

10047

   assert(!lu->finished);

44,873✔

10049

   vcode_select_unit(lu->vunit);

44,873✔

10050

   vcode_opt();

44,873✔

10052

   if (opt_get_verbose(OPT_DUMP_VCODE, istr(lu->name)))

44,873✔

10055

   if (shape != NULL)

44,873✔

10056

      vcode_check_shape(lu->vunit, shape);

90✔

10058

   lu->finished = true;

44,873✔

10059

44,873✔

10061

static void lower_protected_body(lower_unit_t *lu, object_t *obj)

175✔

10063

   tree_t body = tree_from_object(obj);

175✔

10064

   assert(tree_kind(body) == T_PROT_BODY);

175✔

10066

   lu->cscope = cover_create_scope(lu->cover, lu->cscope, body, NULL);

175✔

10068

   if (standard() >= STD_19) {

175✔

10071

      ident_t path_i = well_known(W_PATH_NAME);

49✔

10072

      ident_t inst_i = well_known(W_INSTANCE_NAME);

49✔

10074

      vcode_type_t vchar = vtype_char();

49✔

10075

      vcode_type_t vstring = vtype_uarray(1, vchar, vchar);

49✔

10076

      vcode_reg_t path_reg = emit_param(vstring, vchar, path_i);

49✔

10077

      vcode_reg_t inst_reg = emit_param(vstring, vchar, inst_i);

49✔

10079

      const tree_global_flags_t gflags = tree_global_flags(body);

49✔

10081

      if (gflags & TREE_GF_INSTANCE_NAME) {

49✔

10082

         vcode_var_t path_var = emit_var(vstring, vchar, path_i, VAR_CONST);

46✔

10083

         lower_put_vcode_obj(path_i, path_var, lu);

46✔

10084

         emit_store(path_reg, path_var);

46✔

10087

      if (gflags & TREE_GF_PATH_NAME) {

49✔

10088

         vcode_var_t inst_var = emit_var(vstring, vchar, inst_i, VAR_CONST);

46✔

10089

         lower_put_vcode_obj(inst_i, inst_var, lu);

46✔

10090

         emit_store(inst_reg, inst_var);

46✔

10093

      lower_decls(lu, tree_primary(body));

49✔

10096

   lower_decls(lu, body);

175✔

10097

   emit_return(VCODE_INVALID_REG);

175✔

10098

175✔

10100

static void lower_decls(lower_unit_t *lu, tree_t scope)

29,561✔

10102

   const int ndecls = tree_decls(scope);

29,561✔

10103

   for (int i = 0; i < ndecls; i++) {

263,013✔

10104

      tree_t d = tree_decl(scope, i);

233,452✔

10105

      if (tree_kind(d) != T_ATTR_SPEC)

233,452✔

10106

         continue;

231,422✔

10107

      else if (ident_casecmp(tree_ident(d), well_known(W_FOREIGN)))

2,030✔

10108

         unit_registry_defer(lu->registry, tree_ident2(tree_ref(d)), lu,

762✔

10113

   for (int i = 0; i < ndecls; i++) {

263,013✔

10114

      tree_t d = tree_decl(scope, i);

233,452✔

10115

      switch (tree_kind(d)) {

233,452✔

10116

      case T_FUNC_INST:

39✔

10117

         if (!is_body(tree_ref(d)))

39✔

10122

            ident_t mangled = tree_ident2(d);

19,292✔

10123

            if (!unit_registry_query(lu->registry, mangled))

19,292✔

10124

               unit_registry_defer(lu->registry, mangled, lu,

18,632✔

10129

      case T_PROC_INST:

48✔

10130

         if (!is_body(tree_ref(d)))

48✔

10135

            const bool never_waits = !!(tree_flags(d) & TREE_F_NEVER_WAITS)

4,625✔

10136

               || (tree_flags(d) & TREE_F_PROTECTED);

4,625✔

10137

            emit_fn_t emitfn = never_waits ? emit_function : emit_procedure;

4,625✔

10138

            ident_t mangled = tree_ident2(d);

4,625✔

10140

            if (!unit_registry_query(lu->registry, mangled))

4,625✔

10141

               unit_registry_defer(lu->registry, tree_ident2(d),

4,523✔

10146

      case T_PROT_BODY:

176✔

10147

         unit_registry_defer(lu->registry, type_ident(tree_type(d)),

176✔

10150

         break;

176✔

10151

      case T_FUNC_DECL:

152,988✔

10154

           const subprogram_kind_t kind = tree_subkind(d);

152,988✔

10155

           if (kind == S_USER || is_open_coded_builtin(kind))

152,988✔

10156

              continue;

99,150✔

10158

           unit_registry_defer(lu->registry, tree_ident2(d),

53,838✔

10162

        break;

53,838✔

10163

      default:

56,365✔

10164

         lower_decl(lu, d);

56,365✔

10165

         break;

56,365✔

10168

29,561✔

10170

static bool lower_has_subprograms(tree_t scope)

7,605✔

10172

   const int ndecls = tree_decls(scope);

7,605✔

10173

   for (int i = 0; i < ndecls; i++) {

15,536✔

10174

      tree_t d = tree_decl(scope, i);

8,054✔

10175

      const tree_kind_t kind = tree_kind(d);

8,054✔

10176

      if (kind == T_FUNC_BODY || kind == T_PROC_BODY)

8,054✔

10178

      else if (kind == T_FUNC_INST || kind == T_PROC_INST)

7,973✔

10180

      else if (kind == T_TYPE_DECL) {

7,973✔

10183

         type_t type = tree_type(d);

50✔

10184

         if (type_is_record(type) || type_is_array(type))

50✔

10185

            return true;

42✔

10192

static void lower_subprogram_ports(lower_unit_t *lu, tree_t body,

10,203✔

10195

   const int nports = tree_ports(body);

10,203✔

10196

   for (int i = 0; i < nports; i++) {

27,773✔

10197

      tree_t p = tree_port(body, i);

17,570✔

10198

      type_t type = tree_type(p);

17,570✔

10200

      const class_t class = tree_class(p);

17,570✔

10201

      const port_mode_t mode = tree_subkind(p);

17,570✔

10203

      vcode_type_t vtype = lower_param_type(type, class, mode);

17,570✔

10204

      vcode_type_t vbounds = lower_bounds(type);

17,570✔

10206

      vcode_reg_t preg = emit_param(vtype, vbounds, tree_ident(p));

17,570✔

10207

      if (params_as_vars) {

17,570✔

10208

         vcode_var_t var = emit_var(vtype, vbounds, tree_ident(p), 0);

735✔

10209

         emit_store(preg, var);

735✔

10210

         lower_put_vcode_obj(p, var | PARAM_VAR_BIT, lu);

735✔

10213

         lower_put_vcode_obj(p, preg, lu);

16,835✔

10215

10,203✔

10217

static ident_t lower_predef_func_name(type_t type, const char *op)

441✔

10219

   type_t base = type_base_recur(type);

441✔

10221

   LOCAL_TEXT_BUF tb = tb_new();

882✔

10222

   tb_printf(tb, "%s.\"%s\"(", istr(ident_runtil(type_ident(base), '.')), op);

441✔

10223

   mangle_one_type(tb, base);

441✔

10224

   mangle_one_type(tb, base);

441✔

10225

   tb_cat(tb, ")");

441✔

10226

   mangle_one_type(tb, std_type(NULL, STD_BOOLEAN));

441✔

10227

   tb_cat(tb, "$predef");

441✔

10229

   return ident_new(tb_get(tb));

441✔

10232

static void lower_array_cmp_inner(lower_unit_t *lu,

1,693✔

10245

   assert(pred == VCODE_CMP_EQ || pred == VCODE_CMP_LT

1,693✔

10248

   const int ndims = dimension_of(left_type);

1,693✔

10249

   assert(dimension_of(right_type) == ndims);

1,693✔

10251

   vcode_reg_t left_len = lower_array_len(lu, left_type, 0, lhs_array);

1,693✔

10252

   for (int i = 1; i < ndims; i++) {

1,738✔

10253

      vcode_reg_t dim_len = lower_array_len(lu, left_type, i, lhs_array);

45✔

10254

      left_len = emit_mul(dim_len, left_len);

45✔

10257

   vcode_reg_t right_len = lower_array_len(lu, right_type, 0, rhs_array);

1,693✔

10258

   for (int i = 1; i < ndims; i++) {

1,738✔

10259

      vcode_reg_t dim_len = lower_array_len(lu, right_type, i, rhs_array);

45✔

10260

      right_len = emit_mul(dim_len, right_len);

45✔

10263

   vcode_type_t voffset = vtype_offset();

1,693✔

10264

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

1,693✔

10265

   emit_store(emit_const(voffset, 0), i_var);

1,693✔

10267

   vcode_block_t test_bb = emit_block();

1,693✔

10268

   vcode_block_t body_bb = emit_block();

1,693✔

10269

   vcode_block_t exit_bb = emit_block();

1,693✔

10271

   type_t elem_type = type_elem(left_type);

1,693✔

10273

   vcode_reg_t stride = VCODE_INVALID_REG;

1,693✔

10274

   if (type_is_array(elem_type))

1,693✔

10275

      stride = lower_array_stride(lu, left_type, lhs_array);

177✔

10277

   vcode_reg_t len_eq = emit_cmp(VCODE_CMP_EQ, left_len, right_len);

1,693✔

10279

   if (pred == VCODE_CMP_EQ)

1,693✔

10280

      emit_cond(len_eq, test_bb, fail_bb);

1,547✔

10282

      emit_jump(test_bb);

146✔

10286

   vcode_select_block(test_bb);

1,693✔

10288

   vcode_reg_t i_loaded = emit_load(i_var);

1,693✔

10290

   if (pred == VCODE_CMP_EQ) {

1,693✔

10291

      vcode_reg_t done = emit_cmp(VCODE_CMP_EQ, i_loaded, left_len);

1,547✔

10292

      emit_cond(done, exit_bb, body_bb);

1,547✔

10295

      vcode_block_t check_r_len_bb = emit_block();

146✔

10297

      vcode_reg_t len_ge_l = emit_cmp(VCODE_CMP_GEQ, i_loaded, left_len);

146✔

10298

      emit_cond(len_ge_l, exit_bb, check_r_len_bb);

146✔

10300

      vcode_select_block(check_r_len_bb);

146✔

10302

      vcode_reg_t len_ge_r = emit_cmp(VCODE_CMP_GEQ, i_loaded, right_len);

146✔

10303

      emit_cond(len_ge_r, fail_bb, body_bb);

146✔

10308

   vcode_select_block(body_bb);

1,693✔

10310

   vcode_reg_t ptr_inc = i_loaded;

1,693✔

10311

   if (stride != VCODE_INVALID_REG)

1,693✔

10312

      ptr_inc = emit_mul(ptr_inc, stride);

177✔

10314

   vcode_reg_t inc = emit_add(i_loaded, emit_const(voffset, 1));

1,693✔

10315

   emit_store(inc, i_var);

1,693✔

10317

   vcode_reg_t i_eq_len = emit_cmp(VCODE_CMP_EQ, inc, left_len);

1,693✔

10319

   vcode_reg_t l_ptr = emit_array_ref(lhs_data, ptr_inc);

1,693✔

10320

   vcode_reg_t r_ptr = emit_array_ref(rhs_data, ptr_inc);

1,693✔

10322

   if (type_is_array(elem_type)) {

1,693✔

10323

      vcode_reg_t lhs_sub_array = VCODE_INVALID_REG;

177✔

10324

      vcode_reg_t rhs_sub_array = VCODE_INVALID_REG;

177✔

10325

      if (type_is_unconstrained(elem_type)) {

177✔

10326

         lhs_sub_array = lower_wrap_element(lu, left_type, lhs_array, l_ptr);

30✔

10327

         rhs_sub_array = lower_wrap_element(lu, right_type, rhs_array, r_ptr);

30✔

10330

      lower_array_cmp_inner(lu, l_ptr, r_ptr, lhs_sub_array, rhs_sub_array,

177✔

10333

      emit_jump(test_bb);

177✔

10335

   else if (type_is_record(elem_type)) {

1,516✔

10336

      lower_for_each_field_2(lu, elem_type, elem_type, l_ptr, r_ptr,

109✔

10338

                             (void *)(uintptr_t)fail_bb);

109✔

10339

      emit_jump(test_bb);

109✔

10342

      vcode_reg_t l_val = emit_load_indirect(l_ptr);

1,407✔

10343

      vcode_reg_t r_val = emit_load_indirect(r_ptr);

1,407✔

10345

      if (pred == VCODE_CMP_EQ) {

1,407✔

10346

         vcode_reg_t eq = emit_cmp(pred, l_val, r_val);

1,261✔

10347

         emit_cond(eq, test_bb, fail_bb);

1,261✔

10350

         vcode_reg_t cmp = emit_cmp(pred, l_val, r_val);

146✔

10351

         vcode_reg_t eq  = emit_cmp(VCODE_CMP_EQ, l_val, r_val);

146✔

10353

         vcode_reg_t done = emit_or(emit_not(eq), emit_and(len_eq, i_eq_len));

146✔

10355

         vcode_block_t cmp_result_bb = emit_block();

146✔

10356

         emit_cond(done, cmp_result_bb, test_bb);

146✔

10358

         vcode_select_block(cmp_result_bb);

146✔

10359

         emit_cond(cmp, exit_bb, fail_bb);

146✔

10365

   vcode_select_block(exit_bb);

1,693✔

10366

1,693✔

10368

static void lower_predef_array_cmp(lower_unit_t *lu, tree_t decl,

846✔

10371

   type_t r0_type = tree_type(tree_port(decl, 0));

846✔

10372

   type_t r1_type = tree_type(tree_port(decl, 1));

846✔

10374

   vcode_reg_t r0 = 1, r1 = 2;

846✔

10375

   vcode_reg_t r0_data = lower_array_data(r0);

846✔

10376

   vcode_reg_t r1_data = lower_array_data(r1);

846✔

10378

   vcode_block_t fail_bb = emit_block();

846✔

10380

   lower_array_cmp_inner(lu, r0_data, r1_data, r0, r1, r0_type, r1_type,

846✔

10383

   emit_return(emit_const(vtype_bool(), 1));

846✔

10385

   vcode_select_block(fail_bb);

846✔

10386

   emit_return(emit_const(vtype_bool(), 0));

846✔

10387

846✔

10389

static void lower_predef_field_eq_cb(lower_unit_t *lu, tree_t field,

1,540✔

10393

   vcode_block_t fail_bb = (uintptr_t)context;

1,540✔

10395

   type_t ftype = tree_type(field);

1,540✔

10396

   if (type_is_array(ftype)) {

1,540✔

10397

      vcode_reg_t r0_data = r0, r0_array = VCODE_INVALID_REG;

670✔

10398

      if (have_uarray_ptr(r0)) {

670✔

10399

         r0_array = emit_load_indirect(r0);

33✔

10400

         r0_data = lower_array_data(r0_array);

33✔

10403

      vcode_reg_t r1_data = r1, r1_array = VCODE_INVALID_REG;

670✔

10404

      if (have_uarray_ptr(r1)) {

670✔

10405

         r1_array = emit_load_indirect(r1);

33✔

10406

         r1_data = lower_array_data(r1_array);

33✔

10409

      lower_array_cmp_inner(lu, r0_data, r1_data, r0_array, r1_array,

670✔

10412

   else if (type_is_record(ftype))

870✔

10413

      lower_for_each_field_2(lu, ftype, ftype, r0, r1, locus,

72✔

10415

                             (void *)(uintptr_t)fail_bb);

72✔

10417

      vcode_reg_t r0_load = emit_load_indirect(r0);

798✔

10418

      vcode_reg_t r1_load = emit_load_indirect(r1);

798✔

10419

      vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_EQ, r0_load, r1_load);

798✔

10421

      vcode_block_t next_bb = emit_block();

798✔

10422

      emit_cond(cmp_reg, next_bb, fail_bb);

798✔

10423

      vcode_select_block(next_bb);

798✔

10425

1,540✔

10427

static void lower_predef_record_eq(lower_unit_t *lu, tree_t decl)

222✔

10429

   vcode_reg_t r0 = 1, r1 = 2;

222✔

10430

   type_t type = tree_type(tree_port(decl, 0));

222✔

10432

   vcode_block_t fail_bb = emit_block();

222✔

10434

   lower_for_each_field_2(lu, type, type, r0, r1, VCODE_INVALID_REG,

222✔

10435

                          lower_predef_field_eq_cb, (void *)(uintptr_t)fail_bb);

222✔

10437

   emit_return(emit_const(vtype_bool(), 1));

222✔

10439

   vcode_select_block(fail_bb);

222✔

10440

   emit_return(emit_const(vtype_bool(), 0));

222✔

10441

222✔

10443

static void lower_predef_to_string(lower_unit_t *lu, tree_t decl)

165✔

10447

   type_t arg_type = tree_type(tree_port(decl, 0));

165✔

10448

   vcode_reg_t context_reg = 0, r0 = 1;

165✔

10450

   if (type_is_array(arg_type)) {

165✔

10451

      type_t elem = type_elem(arg_type);

55✔

10452

      if (type_is_enum(elem) && all_character_literals(elem)) {

55✔

10453

         lower_character_array_image_helper(lu, arg_type, r0, false);

39✔

10454

         return;

39✔

10458

   assert(type_is_representable(arg_type));

126✔

10460

   ident_t func = ident_prefix(type_ident(arg_type), ident_new("image"), '$');

126✔

10461

   vcode_type_t ctype = vtype_char();

126✔

10462

   vcode_type_t rtype = vtype_uarray(1, ctype, ctype);

126✔

10463

   vcode_reg_t args[] = { context_reg, r0 };

126✔

10464

   vcode_reg_t str_reg = emit_fcall(func, rtype, ctype, args, 2);

126✔

10466

   if (type_is_enum(arg_type)) {

126✔

10469

      vcode_reg_t quote_reg = emit_const(ctype, '\'');

55✔

10470

      vcode_reg_t data_reg  = lower_array_data(str_reg);

55✔

10471

      vcode_reg_t char0_reg = emit_load_indirect(data_reg);

55✔

10472

      vcode_reg_t is_quote  = emit_cmp(VCODE_CMP_EQ, char0_reg, quote_reg);

55✔

10474

      vcode_block_t char_bb  = emit_block();

55✔

10475

      vcode_block_t other_bb = emit_block();

55✔

10477

      emit_cond(is_quote, char_bb, other_bb);

55✔

10479

      vcode_select_block(char_bb);

55✔

10481

      vcode_reg_t one_reg   = emit_const(vtype_offset(), 1);

55✔

10482

      vcode_reg_t char1_ptr = emit_array_ref(data_reg, one_reg);

55✔

10483

      vcode_reg_t left_reg  = emit_uarray_left(str_reg, 0);

55✔

10484

      vcode_reg_t dir_reg   = emit_uarray_dir(str_reg, 0);

55✔

10486

      vcode_dim_t dims[] = {

55✔

10492

      emit_return(emit_wrap(char1_ptr, dims, 1));

55✔

10494

      vcode_select_block(other_bb);

55✔

10497

   emit_return(str_reg);

126✔

10500

static void lower_predef_bit_shift(lower_unit_t *lu, tree_t decl,

72✔

10503

   type_t type = tree_type(tree_port(decl, 0));

72✔

10504

   type_t elem = type_elem(type);

72✔

10506

   vcode_type_t vtype = lower_type(elem);

72✔

10507

   vcode_type_t vbounds = lower_bounds(elem);

72✔

10508

   vcode_type_t voffset = vtype_offset();

72✔

10510

   vcode_reg_t r0 = 1, r1 = 2;

72✔

10512

   vcode_reg_t data_reg = lower_array_data(r0);

72✔

10513

   vcode_reg_t len_reg  = lower_array_len(lu, type, 0, r0);

72✔

10515

   vcode_block_t null_bb = emit_block();

72✔

10516

   vcode_block_t non_null_bb = emit_block();

72✔

10518

   vcode_reg_t is_null_reg =

72✔

10519

      emit_cmp(VCODE_CMP_EQ, len_reg, emit_const(voffset, 0));

72✔

10520

   emit_cond(is_null_reg, null_bb, non_null_bb);

72✔

10522

   vcode_select_block(null_bb);

72✔

10523

   emit_return(r0);

72✔

10525

   vcode_select_block(non_null_bb);

72✔

10527

   vcode_reg_t shift_reg = emit_cast(voffset, voffset, r1);

72✔

10528

   vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, len_reg);

72✔

10530

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

72✔

10531

   emit_store(emit_const(voffset, 0), i_var);

72✔

10533

   vcode_block_t cmp_bb  = emit_block();

72✔

10534

   vcode_block_t body_bb = emit_block();

72✔

10535

   vcode_block_t exit_bb = emit_block();

72✔

10537

   vcode_reg_t def_reg = VCODE_INVALID_REG;

72✔

10538

   switch (kind) {

72✔

10539

   case S_SLL: case S_SRL: case S_ROL: case S_ROR:

48✔

10540

      def_reg = emit_const(vtype, 0);

48✔

10541

      break;

48✔

10542

   case S_SRA:

12✔

10544

         vcode_reg_t len_minus_1 = emit_sub(len_reg, emit_const(voffset, 1));

12✔

10545

         vcode_reg_t last_ptr = emit_array_ref(data_reg, len_minus_1);

12✔

10546

         def_reg = emit_load_indirect(last_ptr);

12✔

10548

      break;

12✔

10549

   case S_SLA:

12✔

10550

      def_reg = emit_load_indirect(data_reg);

12✔

10551

      break;

12✔

10556

   vcode_reg_t shift_is_neg =

72✔

10557

      emit_cmp(VCODE_CMP_LT, shift_reg, emit_const(voffset, 0));

72✔

10559

   emit_jump(cmp_bb);

72✔

10561

   vcode_select_block(cmp_bb);

72✔

10563

   vcode_reg_t i_reg  = emit_load(i_var);

72✔

10564

   vcode_reg_t eq_reg = emit_cmp(VCODE_CMP_EQ, i_reg, len_reg);

72✔

10565

   emit_cond(eq_reg, exit_bb, body_bb);

72✔

10567

   vcode_select_block(body_bb);

72✔

10569

   vcode_reg_t cmp_reg = VCODE_INVALID_REG;

72✔

10570

   switch (kind) {

72✔

10571

   case S_SRL: case S_SRA:

24✔

10573

         vcode_reg_t neg_reg =

24✔

10574

            emit_cmp(VCODE_CMP_LT, i_reg, emit_add(len_reg, shift_reg));

24✔

10575

         vcode_reg_t pos_reg =

24✔

10576

            emit_cmp(VCODE_CMP_GEQ, i_reg, shift_reg);

24✔

10577

         cmp_reg = emit_select(shift_is_neg, neg_reg, pos_reg);

24✔

10579

      break;

24✔

10580

   case S_SLL: case S_SLA:

24✔

10582

         vcode_reg_t neg_reg =

24✔

10583

            emit_cmp(VCODE_CMP_GEQ, i_reg, emit_neg(shift_reg));

24✔

10584

         vcode_reg_t pos_reg =

24✔

10585

            emit_cmp(VCODE_CMP_LT, i_reg, emit_sub(len_reg, shift_reg));

24✔

10586

         cmp_reg = emit_select(shift_is_neg, neg_reg, pos_reg);

24✔

10588

      break;

24✔

10589

   case S_ROL: case S_ROR:

24✔

10590

      cmp_reg = emit_const(vtype_bool(), 1);

24✔

10595

   vcode_reg_t dst_ptr = emit_array_ref(mem_reg, i_reg);

72✔

10597

   vcode_reg_t next_reg = emit_add(i_reg, emit_const(vtype_offset(), 1));

72✔

10598

   emit_store(next_reg, i_var);

72✔

10600

   vcode_block_t true_bb = emit_block();

72✔

10601

   vcode_block_t false_bb = emit_block();

72✔

10603

   emit_cond(cmp_reg, true_bb, false_bb);

72✔

10605

   vcode_select_block(true_bb);

72✔

10607

   vcode_reg_t src_reg = VCODE_INVALID_REG;

72✔

10608

   switch (kind) {

72✔

10609

   case S_SLL: case S_SLA:

24✔

10610

      src_reg = emit_add(i_reg, shift_reg);

24✔

10611

      break;

24✔

10612

   case S_SRL: case S_SRA:

24✔

10613

      src_reg = emit_sub(i_reg, shift_reg);

24✔

10614

      break;

24✔

10615

   case S_ROL:

12✔

10616

      src_reg = emit_mod(emit_add(i_reg, emit_add(len_reg, shift_reg)),

12✔

10618

      break;

12✔

10619

   case S_ROR:

12✔

10620

      src_reg = emit_mod(emit_add(i_reg, emit_sub(len_reg, shift_reg)),

12✔

10622

      break;

12✔

10627

   vcode_reg_t load_reg = emit_load_indirect(emit_array_ref(data_reg, src_reg));

72✔

10628

   emit_store_indirect(load_reg, dst_ptr);

72✔

10629

   emit_jump(cmp_bb);

72✔

10631

   vcode_select_block(false_bb);

72✔

10632

   emit_store_indirect(def_reg, dst_ptr);

72✔

10633

   emit_jump(cmp_bb);

72✔

10635

   vcode_select_block(exit_bb);

72✔

10637

   vcode_reg_t left_reg  = emit_uarray_left(r0, 0);

72✔

10638

   vcode_reg_t right_reg = emit_uarray_right(r0, 0);

72✔

10639

   vcode_reg_t dir_reg   = emit_uarray_dir(r0, 0);

72✔

10641

   vcode_dim_t dims[] = { { left_reg, right_reg, dir_reg } };

72✔

10642

   emit_return(emit_wrap(mem_reg, dims, 1));

72✔

10643

72✔

10645

static void lower_predef_bit_vec_op(lower_unit_t *lu, tree_t decl,

113✔

10648

   type_t type = tree_type(tree_port(decl, 0));

113✔

10649

   type_t elem = type_elem(type);

113✔

10651

   vcode_type_t vtype = lower_type(elem);

113✔

10652

   vcode_type_t vbounds = lower_bounds(elem);

113✔

10653

   vcode_type_t voffset = vtype_offset();

113✔

10655

   vcode_reg_t r0 = 1, r1 = 2;

113✔

10657

   vcode_reg_t data0_reg = lower_array_data(r0);

113✔

10658

   vcode_reg_t data1_reg = VCODE_INVALID_REG;

113✔

10659

   if (kind != S_ARRAY_NOT)

113✔

10660

      data1_reg = lower_array_data(r1);

96✔

10662

   vcode_reg_t len0_reg = lower_array_len(lu, type, 0, r0);

113✔

10663

   vcode_reg_t len1_reg = VCODE_INVALID_REG;

113✔

10664

   if (kind != S_ARRAY_NOT) {

113✔

10665

      len1_reg = lower_array_len(lu, type, 0, r1);

96✔

10667

      vcode_block_t fail_bb = emit_block();

96✔

10668

      vcode_block_t cont_bb = emit_block();

96✔

10670

      vcode_reg_t len_eq = emit_cmp(VCODE_CMP_EQ, len0_reg, len1_reg);

96✔

10671

      emit_cond(len_eq, cont_bb, fail_bb);

96✔

10673

      vcode_select_block(fail_bb);

96✔

10675

      vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1);

96✔

10676

      vcode_reg_t failure_reg = emit_const(vseverity, SEVERITY_FAILURE);

96✔

10678

      vcode_reg_t msg_reg =

96✔

10679

         lower_wrap_string("arguments have different lengths");

96✔

10680

      vcode_reg_t msg_len = emit_uarray_len(msg_reg, 0);

96✔

10682

      vcode_reg_t locus = lower_debug_locus(decl);

96✔

10683

      emit_report(emit_unwrap(msg_reg), msg_len, failure_reg, locus);

96✔

10684

      emit_return(r0);

96✔

10686

      vcode_select_block(cont_bb);

96✔

10689

   vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, len0_reg);

113✔

10691

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

113✔

10692

   emit_store(emit_const(voffset, 0), i_var);

113✔

10694

   vcode_block_t cmp_bb  = emit_block();

113✔

10695

   vcode_block_t body_bb = emit_block();

113✔

10696

   vcode_block_t exit_bb = emit_block();

113✔

10698

   emit_jump(cmp_bb);

113✔

10700

   vcode_select_block(cmp_bb);

113✔

10702

   vcode_reg_t i_reg  = emit_load(i_var);

113✔

10703

   vcode_reg_t eq_reg = emit_cmp(VCODE_CMP_EQ, i_reg, len0_reg);

113✔

10704

   emit_cond(eq_reg, exit_bb, body_bb);

113✔

10706

   vcode_select_block(body_bb);

113✔

10708

   vcode_reg_t dst_ptr = emit_array_ref(mem_reg, i_reg);

113✔

10710

   vcode_reg_t src0_reg = emit_load_indirect(emit_array_ref(data0_reg, i_reg));

113✔

10711

   vcode_reg_t src1_reg = VCODE_INVALID_REG;

113✔

10712

   if (kind != S_ARRAY_NOT)

113✔

10713

      src1_reg = emit_load_indirect(emit_array_ref(data1_reg, i_reg));

96✔

10715

   vcode_reg_t op_reg;

113✔

10716

   switch (kind) {

113✔

10717

   case S_ARRAY_NOT:  op_reg = emit_not(src0_reg); break;

17✔

10718

   case S_ARRAY_AND:  op_reg = emit_and(src0_reg, src1_reg); break;

38✔

10719

   case S_ARRAY_OR:   op_reg = emit_or(src0_reg, src1_reg); break;

12✔

10720

   case S_ARRAY_XOR:  op_reg = emit_xor(src0_reg, src1_reg); break;

11✔

10721

   case S_ARRAY_XNOR: op_reg = emit_xnor(src0_reg, src1_reg); break;

11✔

10722

   case S_ARRAY_NAND: op_reg = emit_nand(src0_reg, src1_reg); break;

12✔

10723

   case S_ARRAY_NOR:  op_reg = emit_nor(src0_reg, src1_reg); break;

12✔

10728

   emit_store_indirect(op_reg, dst_ptr);

113✔

10730

   vcode_reg_t next_reg = emit_add(i_reg, emit_const(vtype_offset(), 1));

113✔

10731

   emit_store(next_reg, i_var);

113✔

10732

   emit_jump(cmp_bb);

113✔

10734

   vcode_select_block(exit_bb);

113✔

10736

   vcode_reg_t left_reg  = emit_uarray_left(r0, 0);

113✔

10737

   vcode_reg_t right_reg = emit_uarray_right(r0, 0);

113✔

10738

   vcode_reg_t dir_reg   = emit_uarray_dir(r0, 0);

113✔

10740

   vcode_dim_t dims[] = { { left_reg, right_reg, dir_reg } };

113✔

10741

   emit_return(emit_wrap(mem_reg, dims, 1));

113✔

10742

113✔

10744

static void lower_predef_mixed_bit_vec_op(lower_unit_t *lu, tree_t decl,

114✔

10749

   vcode_reg_t r0 = 1, r1 = 2;

114✔

10751

   type_t r0_type = tree_type(tree_port(decl, 0));

114✔

10752

   type_t r1_type = tree_type(tree_port(decl, 1));

114✔

10754

   vcode_type_t voffset = vtype_offset();

114✔

10756

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

114✔

10757

   emit_store(emit_const(vtype_offset(), 0), i_var);

114✔

10759

   const bool r0_is_array = type_is_array(r0_type);

114✔

10761

   type_t array_type = r0_is_array ? r0_type : r1_type;

114✔

10762

   vcode_reg_t array_reg = r0_is_array ? r0 : r1;

114✔

10764

   vcode_reg_t len_reg   = lower_array_len(lu, array_type, 0, array_reg);

114✔

10765

   vcode_reg_t data_reg  = lower_array_data(array_reg);

114✔

10766

   vcode_reg_t left_reg  = lower_array_left(lu, array_type, 0, array_reg);

114✔

10767

   vcode_reg_t right_reg = lower_array_right(lu, array_type, 0, array_reg);

114✔

10768

   vcode_reg_t dir_reg   = lower_array_dir(lu, array_type, 0, array_reg);

114✔

10769

   vcode_reg_t null_reg  = emit_range_null(left_reg, right_reg, dir_reg);

114✔

10771

   vcode_reg_t mem_reg = emit_alloc(vtype_bool(), vtype_bool(), len_reg);

114✔

10773

   vcode_block_t body_bb = emit_block();

114✔

10774

   vcode_block_t exit_bb = emit_block();

114✔

10776

   emit_cond(null_reg, exit_bb, body_bb);

114✔

10778

   vcode_select_block(body_bb);

114✔

10780

   vcode_reg_t i_reg = emit_load(i_var);

114✔

10781

   vcode_reg_t l_reg = emit_load_indirect(emit_array_ref(data_reg, i_reg));

114✔

10782

   vcode_reg_t r_reg = r0_is_array ? r1 : r0;

114✔

10784

   vcode_reg_t result_reg = VCODE_INVALID_REG;

114✔

10785

   switch (kind) {

114✔

10786

   case S_MIXED_AND:  result_reg = emit_and(l_reg, r_reg);  break;

19✔

10787

   case S_MIXED_OR:   result_reg = emit_or(l_reg, r_reg);   break;

19✔

10788

   case S_MIXED_NAND: result_reg = emit_nand(l_reg, r_reg); break;

19✔

10789

   case S_MIXED_NOR:  result_reg = emit_nor(l_reg, r_reg);  break;

19✔

10790

   case S_MIXED_XOR:  result_reg = emit_xor(l_reg, r_reg);  break;

19✔

10791

   case S_MIXED_XNOR: result_reg = emit_xnor(l_reg, r_reg); break;

19✔

10795

   emit_store_indirect(result_reg, emit_array_ref(mem_reg, i_reg));

114✔

10797

   vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1));

114✔

10798

   vcode_reg_t cmp_reg  = emit_cmp(VCODE_CMP_EQ, next_reg, len_reg);

114✔

10799

   emit_store(next_reg, i_var);

114✔

10800

   emit_cond(cmp_reg, exit_bb, body_bb);

114✔

10802

   vcode_select_block(exit_bb);

114✔

10804

   vcode_dim_t dims[1] = {

114✔

10811

   emit_return(emit_wrap(mem_reg, dims, 1));

114✔

10812

114✔

10814

static void lower_predef_reduction_op(lower_unit_t *lu, tree_t decl,

51✔

10817

   vcode_reg_t r0 = 1;

51✔

10818

   type_t r0_type = tree_type(tree_port(decl, 0));

51✔

10820

   vcode_type_t vbool = vtype_bool();

51✔

10821

   vcode_type_t voffset = vtype_offset();

51✔

10823

   vcode_var_t result_var = lower_temp_var(lu, "result", vbool, vbool);

51✔

10824

   vcode_reg_t init_reg =

51✔

10825

      emit_const(vbool, kind == S_REDUCE_NAND || kind == S_REDUCE_AND);

51✔

10826

   emit_store(init_reg, result_var);

51✔

10828

   vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

51✔

10829

   emit_store(emit_const(vtype_offset(), 0), i_var);

51✔

10831

   vcode_reg_t len_reg   = lower_array_len(lu, r0_type, 0, r0);

51✔

10832

   vcode_reg_t data_reg  = lower_array_data(r0);

51✔

10833

   vcode_reg_t left_reg  = lower_array_left(lu, r0_type, 0, r0);

51✔

10834

   vcode_reg_t right_reg = lower_array_right(lu, r0_type, 0, r0);

51✔

10835

   vcode_reg_t dir_reg   = lower_array_dir(lu, r0_type, 0, r0);

51✔

10836

   vcode_reg_t null_reg  = emit_range_null(left_reg, right_reg, dir_reg);

51✔

10838

   vcode_block_t body_bb = emit_block();

51✔

10839

   vcode_block_t exit_bb = emit_block();

51✔

10841

   emit_cond(null_reg, exit_bb, body_bb);

51✔

10843

   vcode_select_block(body_bb);

51✔

10845

   vcode_reg_t i_reg   = emit_load(i_var);

51✔

10846

   vcode_reg_t src_reg = emit_load_indirect(emit_array_ref(data_reg, i_reg));

51✔

10847

   vcode_reg_t cur_reg = emit_load(result_var);

51✔

10849

   vcode_reg_t result_reg = VCODE_INVALID_REG;

51✔

10850

   switch (kind) {

51✔

10851

   case S_REDUCE_OR:

16✔

10853

      result_reg = emit_or(cur_reg, src_reg);

16✔

10854

      break;

16✔

10855

   case S_REDUCE_AND:

19✔

10857

      result_reg = emit_and(cur_reg, src_reg);

19✔

10858

      break;

19✔

10859

   case S_REDUCE_XOR:

16✔

10861

      result_reg = emit_xor(cur_reg, src_reg);

16✔

10862

      break;

16✔

10867

   emit_store(result_reg, result_var);

51✔

10869

   vcode_reg_t next_reg = emit_add(i_reg, emit_const(vtype_offset(), 1));

51✔

10870

   vcode_reg_t cmp_reg  = emit_cmp(VCODE_CMP_EQ, next_reg, len_reg);

51✔

10871

   emit_store(next_reg, i_var);

51✔

10872

   emit_cond(cmp_reg, exit_bb, body_bb);

51✔

10874

   vcode_select_block(exit_bb);

51✔

10876

   if (kind == S_REDUCE_NOR || kind == S_REDUCE_NAND || kind == S_REDUCE_XNOR)

51✔

10877

      emit_return(emit_not(emit_load(result_var)));

24✔

10879

      emit_return(emit_load(result_var));

27✔

10880

51✔

10882

static void lower_predef_match_op(lower_unit_t *lu, tree_t decl,

93✔

10885

   vcode_reg_t r0 = 1, r1 = 2;

93✔

10887

   type_t r0_type = tree_type(tree_port(decl, 0));

93✔

10888

   type_t r1_type = tree_type(tree_port(decl, 1));

93✔

10890

   vcode_cmp_t cmp;

93✔

10891

   bool invert = false;

93✔

10892

   switch (kind) {

93✔

10912

   bool is_array = false, is_bit = false;

93✔

10913

   if (type_is_array(r0_type)) {

93✔

10914

      is_array = true;

50✔

10915

      is_bit = type_ident(type_elem(r0_type)) == well_known(W_STD_BIT);

50✔

10918

      is_bit = type_ident(r0_type) == well_known(W_STD_BIT);

43✔

10920

   vcode_reg_t result = VCODE_INVALID_REG;

93✔

10921

   if (is_array) {

93✔

10922

      assert(kind == S_MATCH_EQ || kind == S_MATCH_NEQ);

50✔

10924

      vcode_reg_t len0_reg = lower_array_len(lu, r0_type, 0, r0);

50✔

10925

      vcode_reg_t len1_reg = lower_array_len(lu, r1_type, 0, r1);

50✔

10927

      vcode_block_t fail_bb = emit_block();

50✔

10928

      vcode_block_t cont_bb = emit_block();

50✔

10930

      vcode_reg_t len_eq = emit_cmp(VCODE_CMP_EQ, len0_reg, len1_reg);

50✔

10931

      emit_cond(len_eq, cont_bb, fail_bb);

50✔

10933

      vcode_select_block(fail_bb);

50✔

10935

      vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1);

50✔

10936

      vcode_reg_t failure_reg = emit_const(vseverity, SEVERITY_FAILURE);

50✔

10938

      vcode_reg_t msg_reg =

50✔

10939

         lower_wrap_string("arguments have different lengths");

50✔

10940

      vcode_reg_t msg_len = emit_uarray_len(msg_reg, 0);

50✔

10942

      vcode_reg_t locus = lower_debug_locus(decl);

50✔

10943

      emit_report(emit_unwrap(msg_reg), msg_len, failure_reg, locus);

50✔

10944

      emit_jump(cont_bb);

50✔

10946

      vcode_select_block(cont_bb);

50✔

10948

      vcode_type_t vtype = lower_type(type_elem(r0_type));

50✔

10949

      vcode_type_t vbounds = lower_bounds(type_elem(r0_type));

50✔

10950

      vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, len0_reg);

50✔

10952

      vcode_var_t result_var = lower_temp_var(lu, "result", vtype, vbounds);

50✔

10953

      emit_store(emit_const(vtype, 0), result_var);

50✔

10955

      vcode_type_t voffset = vtype_offset();

50✔

10956

      vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

50✔

10957

      emit_store(emit_const(vtype_offset(), 0), i_var);

50✔

10959

      vcode_reg_t left_reg  = lower_array_left(lu, r0_type, 0, r0);

50✔

10960

      vcode_reg_t right_reg = lower_array_right(lu, r0_type, 0, r0);

50✔

10961

      vcode_reg_t dir_reg   = lower_array_dir(lu, r0_type, 0, r0);

50✔

10962

      vcode_reg_t null_reg  = emit_range_null(left_reg, right_reg, dir_reg);

50✔

10964

      vcode_reg_t r0_ptr = lower_array_data(r0);

50✔

10965

      vcode_reg_t r1_ptr = lower_array_data(r1);

50✔

10967

      vcode_block_t body_bb = emit_block();

50✔

10968

      vcode_block_t exit_bb = emit_block();

50✔

10970

      emit_cond(null_reg, exit_bb, body_bb);

50✔

10972

      vcode_select_block(body_bb);

50✔

10974

      vcode_reg_t i_reg = emit_load(i_var);

50✔

10976

      vcode_reg_t i0_ptr = emit_array_ref(r0_ptr, i_reg);

50✔

10977

      vcode_reg_t i1_ptr = emit_array_ref(r1_ptr, i_reg);

50✔

10979

      vcode_reg_t r0_src_reg = emit_load_indirect(i0_ptr);

50✔

10980

      vcode_reg_t r1_src_reg = emit_load_indirect(i1_ptr);

50✔

10982

      vcode_reg_t tmp;

50✔

10983

      if (is_bit)

50✔

10984

         tmp = emit_cmp(cmp, r0_src_reg, r1_src_reg);

18✔

10986

         ident_t func = ident_new("NVC.IEEE_SUPPORT.REL_MATCH_EQ(UU)U");

32✔

10987

         vcode_reg_t context_reg = lower_context_for_call(lu, func);

32✔

10988

         vcode_reg_t args[] = { context_reg, r0_src_reg, r1_src_reg };

32✔

10989

         tmp = emit_fcall(func, vtype, vbounds, args, 3);

32✔

10991

      emit_store_indirect(tmp, emit_array_ref(mem_reg, i_reg));

50✔

10993

      vcode_reg_t next_reg = emit_add(i_reg, emit_const(vtype_offset(), 1));

50✔

10994

      vcode_reg_t cmp_reg  = emit_cmp(VCODE_CMP_EQ, next_reg, len0_reg);

50✔

10995

      emit_store(next_reg, i_var);

50✔

10996

      emit_cond(cmp_reg, exit_bb, body_bb);

50✔

10998

      vcode_select_block(exit_bb);

50✔

11000

      vcode_dim_t dims[1] = {

50✔

11007

      vcode_reg_t wrap_reg = emit_wrap(mem_reg, dims, 1);

50✔

11009

      ident_t func = is_bit

100✔

11010

         ? ident_new("STD.STANDARD.\"and\"(Q)J$predef")

18✔

11011

         : ident_new("IEEE.STD_LOGIC_1164.\"and\"(Y)U");

50✔

11012

      vcode_reg_t context_reg = lower_context_for_call(lu, func);

50✔

11013

      vcode_reg_t args[] = { context_reg, wrap_reg };

50✔

11014

      result = emit_fcall(func, vtype, vbounds, args, 2);

50✔

11016

   else if (is_bit)

43✔

11017

      result = emit_cmp(cmp, r0, r1);

30✔

11019

      ident_t func = NULL;

13✔

11020

      switch (cmp) {

13✔

11021

      case VCODE_CMP_LT:

4✔

11022

         func = ident_new("NVC.IEEE_SUPPORT.REL_MATCH_LT(UU)U");

4✔

11023

         break;

4✔

11024

      case VCODE_CMP_LEQ:

4✔

11025

         func = ident_new("NVC.IEEE_SUPPORT.REL_MATCH_LEQ(UU)U");

4✔

11026

         break;

4✔

11027

      case VCODE_CMP_EQ:

5✔

11028

         func = ident_new("NVC.IEEE_SUPPORT.REL_MATCH_EQ(UU)U");

5✔

11029

         break;

5✔

11034

      vcode_reg_t context_reg = lower_context_for_call(lu, func);

13✔

11035

      vcode_reg_t args[3] = { context_reg, r0, r1 };

13✔

11037

      vcode_type_t rtype = lower_type(r0_type);

13✔

11038

      result = emit_fcall(func, rtype, rtype, args, 3);

13✔

11041

   if (invert && is_bit)

93✔

11042

      emit_return(emit_not(result));

24✔

11043

   else if (invert) {

69✔

11044

      ident_t func = ident_new(

22✔

11046

      vcode_reg_t context_reg = lower_context_for_call(lu, func);

22✔

11047

      vcode_reg_t args[2] = { context_reg, result };

22✔

11048

      vcode_type_t rtype = vcode_reg_type(result);

22✔

11049

      emit_return(emit_fcall(func, rtype, rtype, args, 2));

22✔

11052

      emit_return(result);

47✔

11053

93✔

11055

static void lower_predef_min_max(lower_unit_t *lu, tree_t decl, vcode_cmp_t cmp)

373✔

11057

   type_t type = tree_type(tree_port(decl, 0));

373✔

11059

   if (type_is_array(type) && tree_ports(decl) == 1) {

497✔

11060

      type_t elem = type_elem(type);

124✔

11061

      assert(type_is_scalar(elem));

124✔

11063

      vcode_reg_t array_reg = 1;

124✔

11064

      vcode_type_t voffset = vtype_offset();

124✔

11066

      vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset);

124✔

11067

      emit_store(emit_const(voffset, 0), i_var);

124✔

11069

      vcode_type_t elem_vtype = lower_type(elem);

124✔

11070

      vcode_var_t result_var =

124✔

11071

         lower_temp_var(lu, "result", elem_vtype, elem_vtype);

124✔

11073

      tree_t elem_r = range_of(elem, 0);

124✔

11074

      vcode_reg_t def_reg =

248✔

11075

         (cmp == VCODE_CMP_GT && tree_subkind(elem_r) == RANGE_TO)

62✔

11076

         || (cmp == VCODE_CMP_LT && tree_subkind(elem_r) == RANGE_DOWNTO)

62✔

11077

         ? lower_range_left(lu, elem_r)

62✔

11078

         : lower_range_right(lu, elem_r);

186✔

11080

      emit_store(def_reg, result_var);

124✔

11082

      vcode_reg_t left_reg  = lower_array_left(lu, type, 0, array_reg);

124✔

11083

      vcode_reg_t right_reg = lower_array_right(lu, type, 0, array_reg);

124✔

11084

      vcode_reg_t len_reg   = lower_array_len(lu, type, 0, array_reg);

124✔

11085

      vcode_reg_t kind_reg  = lower_array_dir(lu, type, 0, array_reg);

124✔

11086

      vcode_reg_t data_reg  = lower_array_data(array_reg);

124✔

11087

      vcode_reg_t null_reg  = emit_range_null(left_reg, right_reg, kind_reg);

124✔

11089

      vcode_block_t body_bb = emit_block();

124✔

11090

      vcode_block_t exit_bb = emit_block();

124✔

11092

      emit_cond(null_reg, exit_bb, body_bb);

124✔

11094

      vcode_select_block(body_bb);

124✔

11096

      vcode_reg_t i_reg    = emit_load(i_var);

124✔

11097

      vcode_reg_t elem_ptr = emit_array_ref(data_reg, i_reg);

124✔

11098

      vcode_reg_t elem_reg = emit_load_indirect(elem_ptr);

124✔

11099

      vcode_reg_t cur_reg  = emit_load(result_var);

124✔

11100

      vcode_reg_t cmp_reg  = emit_cmp(cmp, elem_reg, cur_reg);

124✔

11101

      vcode_reg_t next_reg = emit_select(cmp_reg, elem_reg, cur_reg);

124✔

11102

      emit_store(next_reg, result_var);

124✔

11104

      vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1));

124✔

11105

      emit_store(i_next, i_var);

124✔

11107

      vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next, len_reg);

124✔

11108

      emit_cond(done_reg, exit_bb, body_bb);

124✔

11110

      vcode_select_block(exit_bb);

124✔

11111

      emit_return(emit_load(result_var));

124✔

11114

      vcode_reg_t context_reg = 0, r0 = 1, r1 = 2;

249✔

11116

      vcode_reg_t test_reg;

249✔

11117

      if (type_is_scalar(type))

249✔

11118

         test_reg = emit_cmp(cmp, r0, r1);

149✔

11120

         const char *op = cmp == VCODE_CMP_GT ? ">" : "<";

100✔

11121

         ident_t func = lower_predef_func_name(type, op);

100✔

11122

         vcode_reg_t args[] = { context_reg, r0, r1 };

100✔

11123

         vcode_type_t vbool = vtype_bool();

100✔

11124

         test_reg = emit_fcall(func, vbool, vbool, args, 3);

100✔

11127

      emit_return(emit_select(test_reg, r0, r1));

249✔

11129

373✔

11131

static void lower_predef_negate(tree_t decl, const char *op)

249✔

11133

   type_t type = tree_type(tree_port(decl, 0));

249✔

11134

   vcode_type_t vbool = vtype_bool();

249✔

11135

   vcode_reg_t args[] = { 0, 1, 2 };

249✔

11136

   vcode_reg_t eq_reg = emit_fcall(lower_predef_func_name(type, op),

249✔

11139

   emit_return(emit_not(eq_reg));

249✔

11140

249✔

11142

static void lower_foreign_predef(lower_unit_t *lu, tree_t decl, const char *fn)

135✔

11144

   static const char prefix[] = "INTERNAL ";

135✔

11145

   const size_t fnlen = strlen(fn);

135✔

11146

   const size_t nchars = fnlen + sizeof(prefix) - 1;

135✔

11147

   vcode_reg_t *chars LOCAL = xmalloc_array(nchars, sizeof(vcode_reg_t));

270✔

11148

   vcode_type_t ctype = vtype_char();

135✔

11149

   vcode_type_t stype = vtype_carray(nchars, ctype, ctype);

135✔

11151

   int pos = 0;

135✔

11152

   for (int i = 0; i < sizeof(prefix) - 1; i++)

1,350✔

11153

      chars[pos++] = emit_const(ctype, prefix[i]);

1,215✔

11154

   for (int i = 0; i < fnlen; i++)

2,368✔

11155

      chars[pos++] = emit_const(ctype, fn[i]);

2,233✔

11156

   assert(pos == nchars);

135✔

11158

   vcode_reg_t array_reg = emit_const_array(stype, chars, nchars);

135✔

11159

   vcode_reg_t data_reg = emit_address_of(array_reg);

135✔

11160

   vcode_reg_t length_reg = emit_const(vtype_offset(), nchars);

135✔

11162

   emit_bind_foreign(data_reg, length_reg, VCODE_INVALID_REG);

135✔

11163

   emit_unreachable(VCODE_INVALID_REG);

135✔

11164

135✔

11166

static void lower_predef_file_open3(lower_unit_t *lu, tree_t decl)

4✔

11168

   vcode_type_t rtype = vcode_unit_result(lu->vunit);

4✔

11169

   vcode_var_t status_var = emit_var(rtype, rtype, ident_new("status"), 0);

4✔

11171

   vcode_reg_t status_reg = emit_index(status_var, VCODE_INVALID_REG);

4✔

11172

   vcode_reg_t data_reg = emit_unwrap(2);

4✔

11173

   vcode_reg_t length_reg = emit_uarray_len(2, 0);

4✔

11175

   emit_file_open(1, data_reg, length_reg, 3, status_reg);

4✔

11176

   emit_return(emit_load(status_var));

4✔

11177

4✔

11179

static void lower_edge_predef(lower_unit_t *lu, tree_t decl)

20✔

11181

   vcode_reg_t nets_reg = vcode_param_reg(1);

20✔

11182

   vcode_reg_t count_reg = emit_const(vtype_offset(), 1);

20✔

11183

   vcode_reg_t value_reg =

20✔

11184

      emit_load_indirect(emit_resolved(nets_reg, count_reg));

20✔

11186

   if (tree_subkind(decl) == S_FALLING_EDGE)

20✔

11187

      value_reg = emit_not(value_reg);

10✔

11189

   vcode_reg_t event_reg = emit_event_flag(nets_reg, count_reg);

20✔

11190

   emit_return(emit_and(event_reg, value_reg));

20✔

11191

20✔

11193

static void lower_predef(lower_unit_t *lu, object_t *obj)

2,457✔

11195

   tree_t decl = tree_from_object(obj);

2,457✔

11197

   const subprogram_kind_t kind = tree_subkind(decl);

2,457✔

11198

   assert(kind != S_USER);

2,457✔

11199

   assert(!is_open_coded_builtin(kind));

2,457✔

11201

   type_t type = tree_type(decl);

2,457✔

11202

   if (type_has_result(type))

2,457✔

11203

      vcode_set_result(lower_func_result_type(type_result(type)));

2,385✔

11205

   vcode_type_t vcontext = vtype_context(lu->parent->name);

2,457✔

11206

   emit_param(vcontext, vcontext, ident_new("context"));

2,457✔

11208

   lower_subprogram_ports(lu, decl, false);

2,457✔

11210

   switch (tree_subkind(decl)) {

2,457✔

11211

   case S_ARRAY_EQ:

700✔

11212

      lower_predef_array_cmp(lu, decl, VCODE_CMP_EQ);

700✔

11213

      break;

700✔

11214

   case S_ARRAY_LE:

69✔

11215

      lower_predef_array_cmp(lu, decl, VCODE_CMP_LEQ);

69✔

11216

      break;

69✔

11217

   case S_ARRAY_LT:

77✔

11218

      lower_predef_array_cmp(lu, decl, VCODE_CMP_LT);

77✔

11219

      break;

77✔

11220

   case S_ARRAY_GE:

69✔

11221

      lower_predef_negate(decl, "<");

69✔

11222

      break;

69✔

11223

   case S_ARRAY_GT:

69✔

11224

      lower_predef_negate(decl, "<=");

69✔

11225

      break;

69✔

11226

   case S_RECORD_EQ:

222✔

11227

      lower_predef_record_eq(lu, decl);

222✔

11228

      break;

222✔

11229

   case S_ARRAY_NEQ:

111✔

11231

      lower_predef_negate(decl, "=");

111✔

11232

      break;

111✔

11233

   case S_TO_STRING:

165✔

11234

      lower_predef_to_string(lu, decl);

165✔

11235

      break;

165✔

11236

   case S_TO_STRING_TIME:

8✔

11237

      lower_foreign_predef(lu, decl, "_std_to_string_time");

8✔

11238

      break;

8✔

11239

   case S_TO_STRING_REAL_DIGITS:

5✔

11240

      lower_foreign_predef(lu, decl, "_std_to_string_real_digits");

5✔

11241

      break;

5✔

11242

   case S_TO_STRING_REAL_FORMAT:

5✔

11243

      lower_foreign_predef(lu, decl, "_std_to_string_real_format");

5✔

11244

      break;

5✔

11245

   case S_TO_HSTRING_BITVEC:

5✔

11246

      lower_foreign_predef(lu, decl, "_std_to_hstring_bit_vec");

5✔

11247

      break;

5✔

11248

   case S_TO_OSTRING_BITVEC:

5✔

11249

      lower_foreign_predef(lu, decl, "_std_to_ostring_bit_vec");

5✔

11250

      break;

5✔

11251

   case S_SLL:

72✔

11257

      lower_predef_bit_shift(lu, decl, kind);

72✔

11258

      break;

72✔

11259

   case S_ARRAY_NOT:

113✔

11266

      lower_predef_bit_vec_op(lu, decl, kind);

113✔

11267

      break;

113✔

11268

   case S_MIXED_AND:

114✔

11274

      lower_predef_mixed_bit_vec_op(lu, decl, kind);

114✔

11275

      break;

114✔

11276

   case S_REDUCE_OR:

51✔

11282

      lower_predef_reduction_op(lu, decl, kind);

51✔

11283

      break;

51✔

11284

   case S_MATCH_EQ:

93✔

11290

      lower_predef_match_op(lu, decl, kind);

93✔

11291

      break;

93✔

11292

   case S_MAXIMUM:

188✔

11293

      lower_predef_min_max(lu, decl, VCODE_CMP_GT);

188✔

11294

      break;

188✔

11295

   case S_MINIMUM:

185✔

11296

      lower_predef_min_max(lu, decl, VCODE_CMP_LT);

185✔

11297

      break;

185✔

11298

   case S_FILE_FLUSH:

8✔

11299

      lower_foreign_predef(lu, decl, "__nvc_flush");

8✔

11300

      break;

8✔

11301

   case S_FILE_OPEN3:

4✔

11302

      lower_predef_file_open3(lu, decl);

4✔

11303

      break;

4✔

11304

   case S_FILE_CLOSE:

52✔

11305

      lower_foreign_predef(lu, decl, "__nvc_file_close");

52✔

11306

      break;

52✔

11307

   case S_ENDFILE:

15✔

11308

      lower_foreign_predef(lu, decl, "__nvc_endfile");

15✔

11309

      break;

15✔

11310

   case S_FILE_MODE:

4✔

11311

      lower_foreign_predef(lu, decl, "__nvc_file_mode");

4✔

11312

      break;

4✔

11313

   case S_FILE_CANSEEK:

4✔

11314

      lower_foreign_predef(lu, decl, "__nvc_file_canseek");

4✔

11315

      break;

4✔

11316

   case S_FILE_SIZE:

4✔

11317

      lower_foreign_predef(lu, decl, "__nvc_file_size");

4✔

11318

      break;

4✔

11319

   case S_FILE_REWIND:

4✔

11320

      lower_foreign_predef(lu, decl, "__nvc_rewind");

4✔

11321

      break;

4✔

11322

   case S_FILE_SEEK:

4✔

11323

      lower_foreign_predef(lu, decl, "__nvc_seek");

4✔

11324

      break;

4✔

11325

   case S_FILE_TRUNCATE:

4✔

11326

      lower_foreign_predef(lu, decl, "__nvc_truncate");

4✔

11327

      break;

4✔

11328

   case S_FILE_STATE:

4✔

11329

      lower_foreign_predef(lu, decl, "__nvc_file_state");

4✔

11330

      break;

4✔

11331

   case S_FILE_POSITION:

4✔

11332

      lower_foreign_predef(lu, decl, "__nvc_file_position");

4✔

11333

      break;

4✔

11334

   case S_RISING_EDGE:

20✔

11336

      return lower_edge_predef(lu, decl);

20✔

11342

static void lower_proc_body(lower_unit_t *lu, object_t *obj)

1,495✔

11344

   tree_t body = tree_from_object(obj);

1,495✔

11345

   assert(!is_uninstantiated_subprogram(body));

1,495✔

11347

   lu->cscope = cover_create_scope(lu->cover, lu->parent->cscope, body, NULL);

1,495✔

11349

   vcode_type_t vcontext = vtype_context(lu->parent->name);

1,495✔

11350

   emit_param(vcontext, vcontext, ident_new("context"));

1,495✔

11352

   if (tree_kind(body) == T_PROC_INST)

1,495✔

11353

      lower_generics(lu, body, NULL);

39✔

11355

   const bool never_waits = vcode_unit_kind(lu->vunit) == VCODE_UNIT_FUNCTION;

1,495✔

11356

   const bool has_subprograms = lower_has_subprograms(body);

1,495✔

11357

   lower_subprogram_ports(lu, body, has_subprograms || !never_waits);

1,495✔

11359

   lower_decls(lu, body);

1,495✔

11361

   lower_sequence(lu, body, NULL);

1,495✔

11363

   if (!vcode_block_finished()) {

1,495✔

11364

      lower_leave_subprogram(lu);

1,495✔

11365

      emit_return(VCODE_INVALID_REG);

1,495✔

11367

1,495✔

11369

static void lower_func_body(lower_unit_t *lu, object_t *obj)

6,110✔

11371

   tree_t body = tree_from_object(obj);

6,110✔

11372

   assert(!is_uninstantiated_subprogram(body));

6,110✔

11374

   type_t result = type_result(tree_type(body));

6,110✔

11375

   vcode_set_result(lower_func_result_type(result));

6,110✔

11377

   vcode_type_t vcontext = vtype_context(lu->parent->name);

6,110✔

11378

   emit_param(vcontext, vcontext, ident_new("context"));

6,110✔

11380

   lu->cscope = cover_create_scope(lu->cover, lu->parent->cscope, body, NULL);

6,110✔

11382

   if (tree_kind(body) == T_FUNC_INST)

6,110✔

11383

      lower_generics(lu, body, NULL);

39✔

11385

   const bool has_subprograms = lower_has_subprograms(body);

6,110✔

11386

   lower_subprogram_ports(lu, body, has_subprograms);

6,110✔

11388

   if (tree_flags(body) & TREE_F_KNOWS_SUBTYPE) {

6,110✔

11390

      vcode_type_t vresult = lower_param_type(result, C_CONSTANT, PORT_IN);

9✔

11391

      vcode_reg_t bounds_reg =

9✔

11392

         emit_param(vresult, vresult, ident_new("result"));

9✔

11394

      lower_put_vcode_obj(body, bounds_reg, lu);

9✔

11397

   lower_decls(lu, body);

6,110✔

11399

   lower_sequence(lu, body, NULL);

6,110✔

11401

   if (!vcode_block_finished())

6,110✔

11402

      emit_unreachable(lower_debug_locus(body));

90✔

11403

6,110✔

11405

static void lower_driver_field_cb(lower_unit_t *lu, tree_t field,

2,737✔

11409

   tree_t view = untag_pointer(__ctx, void), elem = NULL;

2,737✔

11410

   bool converse = !!pointer_tag(__ctx);

2,737✔

11412

   type_t type = tree_type(field);

2,737✔

11414

   if (view != NULL) {

2,737✔

11415

      elem = find_element_mode_indication(view, field, &converse);

30✔

11416

      assert(elem != NULL);

30✔

11418

      if (converse_mode(elem, converse) == PORT_IN)

30✔

11419

         return;

15✔

11422

   if (type_is_homogeneous(type)) {

2,722✔

11423

      vcode_reg_t nets_reg = emit_load_indirect(ptr);

2,618✔

11424

      vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

2,618✔

11425

      vcode_reg_t data_reg = lower_array_data(nets_reg);

2,618✔

11427

      emit_drive_signal(data_reg, count_reg);

2,618✔

11429

   else if (elem != NULL && tree_subkind(elem) == PORT_RECORD_VIEW) {

104✔

11435

      lower_for_each_field(lu, type, ptr, VCODE_INVALID_REG,

104✔

11439

static bool can_use_transfer_signal(tree_t proc, driver_set_t *ds)

8,922✔

11441

   driver_info_t *di = get_drivers(ds, proc);

8,922✔

11442

   if (di == NULL || di->chain_proc != NULL)

8,922✔

11444

   else if (tree_stmts(proc) != 2)

5,463✔

11447

   tree_t s0 = tree_stmt(proc, 0);

4,583✔

11448

   if (tree_kind(s0) != T_SIGNAL_ASSIGN)

4,583✔

11450

   else if (tree_target(s0) != di->prefix)

3,653✔

11452

   else if (!type_is_homogeneous(tree_type(di->prefix)))

3,644✔

11454

   else if (tree_waveforms(s0) != 1)

3,124✔

11457

   tree_t w0 = tree_waveform(s0, 0);

3,034✔

11458

   if (tree_has_delay(w0)) {

3,034✔

11459

      tree_t d = tree_delay(w0);

474✔

11460

      if (tree_kind(d) != T_LITERAL)

474✔

11464

   if (tree_has_reject(s0)) {

3,028✔

11465

      tree_t r = tree_reject(s0);

468✔

11466

      if (tree_kind(r) != T_LITERAL)

468✔

11470

   tree_t value = tree_value(w0), ref = name_to_ref(value);

3,025✔

11471

   if (ref == NULL || class_of(ref) != C_SIGNAL)

3,025✔

11472

      return false;

1,765✔

11473

   else if (value != longest_static_prefix(value))

1,260✔

11476

   tree_t s1 = tree_stmt(proc, 1);

1,242✔

11477

   if (tree_kind(s1) != T_WAIT)

1,242✔

11479

   else if (!(tree_flags(s1) & TREE_F_STATIC_WAIT))

1,242✔

11481

   else if (tree_triggers(s1) != 1)

1,242✔

11484

   tree_t t0 = tree_trigger(s1, 0);

1,242✔

11485

   if (!same_tree(t0, value))

1,242✔

11486

      return false;

33✔

11491

static vcode_reg_t lower_trigger(lower_unit_t *lu, tree_t fcall, tree_t proc)

509✔

11493

   tree_t decl = tree_ref(fcall);

509✔

11495

   const subprogram_kind_t kind = tree_subkind(decl);

509✔

11496

   if (kind == S_SCALAR_EQ) {

509✔

11497

      tree_t p0 = tree_value(tree_param(fcall, 0)), p1;

69✔

11499

      if (is_literal(p0))   // Commute arguments

69✔

11502

         p1 = tree_value(tree_param(fcall, 1));

69✔

11504

      if (tree_kind(p0) != T_REF || class_of(p0) != C_SIGNAL)

69✔

11505

         return VCODE_INVALID_REG;

6✔

11506

      else if (!is_literal(p1))

63✔

11509

      vcode_reg_t left_reg = lower_lvalue(lu, p0);

63✔

11510

      vcode_reg_t right_reg = lower_rvalue(lu, p1);

63✔

11512

      return emit_cmp_trigger(left_reg, right_reg);

63✔

11514

   else if (kind == S_SCALAR_AND) {

440✔

11517

      tree_t w = tree_stmt(proc, 1);

230✔

11518

      assert(tree_kind(w) == T_WAIT);

230✔

11520

      if (tree_triggers(w) != 1)

230✔

11523

      tree_t p0 = tree_value(tree_param(fcall, 0));

4✔

11524

      tree_t p1 = tree_value(tree_param(fcall, 1));

4✔

11525

      tree_t aref, other;

4✔

11527

      if (tree_kind(p0) == T_ATTR_REF)

4✔

11534

      if (tree_subkind(aref) != ATTR_EVENT)

4✔

11536

      else if (tree_kind(other) != T_FCALL)

4✔

11539

      if (!same_tree(tree_name(aref), tree_trigger(w, 0)))

4✔

11542

      return lower_trigger(lu, other, proc);

4✔

11544

   else if (kind != S_USER && kind != S_FALLING_EDGE && kind != S_RISING_EDGE)

210✔

11546

   else if (tree_flags(decl) & TREE_F_IMPURE)

149✔

11549

   const int nparams = tree_params(fcall);

149✔

11550

   if (nparams != tree_ports(decl))

149✔

11553

   for (int i = 0; i < nparams; i++) {

291✔

11554

      tree_t p = tree_param(fcall, i);

149✔

11555

      tree_t value = tree_value(p);

149✔

11556

      if (is_literal(value))

149✔

11558

      else if (tree_kind(value) == T_REF && class_of(value) == C_SIGNAL) {

149✔

11560

         if (tree_subkind(p) != P_POS)

146✔

11562

         else if (tree_class(tree_port(decl, tree_pos(p))) != C_SIGNAL)

146✔

11566

         return VCODE_INVALID_REG;

3✔

11569

   ident_t name = tree_ident2(decl);

142✔

11571

   vcode_reg_t *args LOCAL = xmalloc_array(nparams + 1, sizeof(vcode_reg_t));

284✔

11572

   args[0] = lower_context_for_call(lu, name);

142✔

11574

   for (int i = 0; i < nparams; i++)

284✔

11575

      args[i + 1] = lower_subprogram_arg(lu, fcall, i);

142✔

11577

   return emit_function_trigger(name, args, nparams + 1);

142✔

11580

static vcode_reg_t lower_process_trigger(lower_unit_t *lu, tree_t proc)

3,765✔

11582

   if (cover_enabled(lu->cover, COVER_MASK_BRANCH | COVER_MASK_EXPRESSION))

3,765✔

11584

   else if (tree_stmts(proc) != 2)

3,457✔

11588

   assert(tree_kind(tree_stmt(proc, 1)) == T_WAIT);

3,374✔

11589

   assert(tree_flags(tree_stmt(proc, 1)) & TREE_F_STATIC_WAIT);

3,374✔

11591

   tree_t s0 = tree_stmt(proc, 0);

3,374✔

11592

   if (tree_kind(s0) != T_IF)

3,374✔

11595

   const int nconds = tree_conds(s0);

517✔

11596

   if (nconds > 2)

517✔

11599

   vcode_reg_t branches[2] = { VCODE_INVALID_REG, VCODE_INVALID_REG };

511✔

11600

   for (int i = 0; i < nconds; i++) {

1,016✔

11601

      tree_t c = tree_cond(s0, i);

798✔

11602

      if (!tree_has_value(c))

798✔

11605

      tree_t value = tree_value(c);

555✔

11606

      if (tree_kind(value) != T_FCALL)

555✔

11609

      branches[i] = lower_trigger(lu, value, proc);

505✔

11612

   if (nconds == 1)

218✔

11613

      return branches[0];

174✔

11614

   else if (branches[0] == VCODE_INVALID_REG

44✔

11615

            || branches[1] == VCODE_INVALID_REG)

41✔

11618

      return emit_or_trigger(branches[0], branches[1]);

31✔

11621

void lower_process(lower_unit_t *parent, tree_t proc, driver_set_t *ds)

8,922✔

11623

   assert(tree_kind(proc) == T_PROCESS);

8,922✔

11625

   ident_t label = tree_ident(proc);

8,922✔

11626

   ident_t name = ident_prefix(parent->name, label, '.');

8,922✔

11627

   vcode_unit_t vu = emit_process(name, tree_to_object(proc), parent->vunit);

8,922✔

11632

   vcode_block_t start_bb = emit_block();

8,922✔

11633

   assert(start_bb == 1);

8,922✔

11635

   lower_unit_t *lu = lower_unit_new(parent->registry, parent, vu,

8,922✔

11637

   unit_registry_put(parent->registry, lu);

8,922✔

11639

   lu->cscope = cover_create_scope(lu->cover, parent->cscope, proc, NULL);

8,922✔

11641

   if (tree_global_flags(proc) & TREE_GF_EXTERNAL_NAME)

8,922✔

11642

      tree_visit_only(proc, lower_external_name_cache, lu, T_EXTERNAL_NAME);

115✔

11644

   lower_decls(lu, proc);

8,922✔

11646

   driver_info_t *di = get_drivers(ds, proc);

8,922✔

11647

   for (; di; di = di->chain_proc) {

25,095✔

11648

      assert(!di->tentative);

7,251✔

11649

      type_t prefix_type = tree_type(di->prefix);

7,251✔

11650

      vcode_reg_t nets_reg = lower_lvalue(lu, di->prefix);

7,251✔

11652

      if (!type_is_homogeneous(prefix_type))

7,251✔

11653

         lower_for_each_field(lu, prefix_type, nets_reg, VCODE_INVALID_REG,

739✔

11654

                              lower_driver_field_cb, di->view);

739✔

11656

         assert(di->view == NULL);

6,512✔

11657

         vcode_reg_t count_reg = lower_type_width(lu, prefix_type, nets_reg);

6,512✔

11658

         emit_drive_signal(lower_array_data(nets_reg), count_reg);

6,512✔

11662

   const bool transfer = can_use_transfer_signal(proc, ds);

8,922✔

11663

   vcode_reg_t trigger_reg = VCODE_INVALID_REG;

8,922✔

11665

   if (transfer) {

8,922✔

11666

      tree_t s0 = tree_stmt(proc, 0);

1,209✔

11667

      assert(tree_kind(s0) == T_SIGNAL_ASSIGN);

1,209✔

11668

      assert(tree_waveforms(s0) == 1);

1,209✔

11670

      emit_debug_info(tree_loc(s0));

1,209✔

11672

      tree_t target = tree_target(s0);

1,209✔

11673

      vcode_reg_t target_reg = lower_lvalue(lu, target);

1,209✔

11675

      tree_t w0 = tree_waveform(s0, 0);

1,209✔

11676

      vcode_reg_t source_reg = lower_lvalue(lu, tree_value(w0));

1,209✔

11678

      vcode_reg_t count_reg =

1,209✔

11679

         lower_type_width(lu, tree_type(target), target_reg);

1,209✔

11681

      vcode_reg_t delay_reg;

1,209✔

11682

      if (tree_has_delay(w0))

1,209✔

11683

         delay_reg = lower_rvalue(lu, tree_delay(w0));

336✔

11685

         delay_reg = emit_const(vtype_time(), 0);

873✔

11687

      vcode_reg_t reject_reg = delay_reg;

1,209✔

11688

      if (tree_has_reject(s0))

1,209✔

11689

         reject_reg = lower_rvalue(lu, tree_reject(s0));

336✔

11691

      vcode_reg_t target_nets = lower_array_data(target_reg);

1,209✔

11692

      vcode_reg_t source_nets = lower_array_data(source_reg);

1,209✔

11693

      emit_transfer_signal(target_nets, source_nets, count_reg,

1,209✔

11700

      tree_t wait = NULL;

7,713✔

11701

      const int nstmts = tree_stmts(proc);

7,713✔

11702

      if (nstmts > 0

7,713✔

11703

          && tree_kind((wait = tree_stmt(proc, nstmts - 1))) == T_WAIT

7,712✔

11704

          && (tree_flags(wait) & TREE_F_STATIC_WAIT)) {

7,541✔

11706

         const int ntriggers = tree_triggers(wait);

3,765✔

11707

         for (int i = 0; i < ntriggers; i++)

7,447✔

11708

            lower_sched_event(lu, tree_trigger(wait, i));

3,682✔

11710

         trigger_reg = lower_process_trigger(lu, proc);

3,765✔

11712

         if (trigger_reg != VCODE_INVALID_REG)

3,765✔

11713

            emit_add_trigger(trigger_reg);

155✔

11717

   emit_return(VCODE_INVALID_REG);

8,922✔

11719

   vcode_select_block(start_bb);

8,922✔

11721

   if (transfer)

8,922✔

11722

      emit_return(VCODE_INVALID_REG);

1,209✔

11723

   else if (trigger_reg != VCODE_INVALID_REG) {

7,713✔

11724

      tree_t s0 = tree_stmt(proc, 0);

155✔

11725

      assert(tree_kind(s0) == T_IF);

155✔

11726

      lower_stmt_coverage(lu, s0);

155✔

11728

      const int nconds = tree_conds(s0);

155✔

11729

      if (nconds == 1) {

155✔

11730

         tree_t c = tree_cond(s0, 0);

124✔

11731

         PUSH_COVER_SCOPE(lu, c);

248✔

11732

         lower_sequence(lu, c, NULL);

124✔

11735

         assert(nconds == 2);

31✔

11736

         tree_t c0 = tree_cond(s0, 0), c1 = tree_cond(s0, 1);

31✔

11738

         vcode_reg_t test = lower_rvalue(lu, tree_value(c0));

31✔

11739

         vcode_block_t btrue = emit_block();

31✔

11740

         vcode_block_t bfalse = emit_block();

31✔

11741

         vcode_block_t bjoin = emit_block();

31✔

11742

         emit_cond(test, btrue, bfalse);

31✔

11745

            vcode_select_block(btrue);

31✔

11747

            PUSH_COVER_SCOPE(lu, c0);

62✔

11748

            lower_sequence(lu, c0, NULL);

31✔

11750

            if (!vcode_block_finished())

31✔

11751

               emit_jump(bjoin);

31✔

11755

            vcode_select_block(bfalse);

31✔

11757

            PUSH_COVER_SCOPE(lu, c1);

62✔

11758

            lower_sequence(lu, c1, NULL);

31✔

11760

            if (!vcode_block_finished())

31✔

11761

               emit_jump(bjoin);

31✔

11764

         vcode_select_block(bjoin);

31✔

11767

      tree_t s1 = tree_stmt(proc, 1);

155✔

11768

      assert(tree_kind(s1) == T_WAIT);

155✔

11770

      lower_wait(lu, s1);

155✔

11773

      lower_sequence(lu, proc, NULL);

7,558✔

11775

   if (!vcode_block_finished())

8,922✔

11776

      emit_jump(start_bb);

7,713✔

11778

   lower_finished(lu, NULL);

8,922✔

11779

   unit_registry_finalise(parent->registry, lu);

8,922✔

11780

8,922✔

11782

static bool lower_is_signal_ref(tree_t expr)

20,410✔

11784

   switch (tree_kind(expr)) {

28,188✔

11785

   case T_REF:

18,452✔

11786

      return class_of(tree_ref(expr)) == C_SIGNAL;

18,452✔

11788

   case T_ALIAS:

7,778✔

11794

      return lower_is_signal_ref(tree_value(expr));

7,778✔

11801

static void lower_conv_field_cb(lower_unit_t *lu, tree_t field,

168✔

11805

   type_t ftype = tree_type(field);

168✔

11807

   if (type_is_homogeneous(ftype)) {

168✔

11808

      vcode_reg_t nets_reg = emit_load_indirect(target_ptr);

168✔

11809

      vcode_reg_t count_reg, data_reg = result_ptr;

168✔

11810

      if (type_is_array(ftype)) {

168✔

11811

         count_reg = lower_array_total_len(lu, ftype, nets_reg);

138✔

11812

         data_reg = lower_array_data(result_ptr);

138✔

11813

         nets_reg = lower_array_data(nets_reg);

138✔

11816

         count_reg = emit_const(vtype_offset(), 1);

30✔

11817

         nets_reg = emit_load_indirect(target_ptr);

30✔

11820

      vcode_reg_t cf_reg = (uintptr_t)ctx;

168✔

11821

      emit_put_conversion(cf_reg, nets_reg, count_reg, data_reg);

168✔

11826

168✔

11828

static vcode_reg_t lower_converter(lower_unit_t *parent, tree_t dst, tree_t src,

310✔

11831

   type_t dst_type = tree_type(dst);

310✔

11832

   type_t src_type = tree_type(src);

310✔

11833

   type_t conv_type = tree_type(conv);

310✔

11836

   const tree_kind_t kind = tree_kind(conv);

310✔

11837

   if (kind == T_TYPE_CONV) {

310✔

11838

      if (type_is_array(conv_type) && type_is_array(src_type)) {

31✔

11839

         if (type_eq(type_elem(conv_type), type_elem(src_type)))

13✔

11842

      else if (type_is_enum(conv_type) && type_is_enum(src_type))

18✔

11846

   vcode_state_t state;

303✔

11847

   vcode_state_save(&state);

303✔

11849

   ident_t name;

303✔

11850

   if (tree_kind(dst) == T_PORT_DECL)

303✔

11851

      name = ident_sprintf("%s.%s.convert_%s", istr(parent->name),

104✔

11855

      name = ident_uniq("%s.%s.convert_%s.part", istr(parent->name),

306✔

11859

   vcode_unit_t vu = emit_function(name, tree_to_object(dst), parent->vunit);

303✔

11860

   emit_debug_info(tree_loc(src));

303✔

11863

   vcode_type_t voffset = vtype_offset();

303✔

11864

   vcode_set_result(voffset);

303✔

11866

   lower_unit_t *lu = lower_unit_new(parent->registry, parent, vu, NULL, NULL);

303✔

11867

   unit_registry_put(parent->registry, lu);

303✔

11869

   vcode_type_t vcontext = vtype_context(parent->name);

303✔

11870

   emit_param(vcontext, vcontext, ident_new("context"));

303✔

11872

   vcode_type_t vconv = vtype_conversion();

303✔

11873

   vcode_reg_t cf_reg = emit_param(vconv, vconv, ident_new("cf"));

303✔

11875

   vcode_reg_t target_reg;

303✔

11876

   if (tree_kind(dst) == T_PORT_DECL)

303✔

11877

      target_reg = lower_port_ref(lu, dst);

104✔

11879

      target_reg = lower_lvalue(lu, dst);

199✔

11881

   vcode_reg_t in_reg;

303✔

11882

   if (dir == PORT_IN)

303✔

11883

      in_reg = lower_rvalue(lu, src);

196✔

11885

      in_reg = lower_driving_value(lu, src);

107✔

11887

   vcode_reg_t result_reg = in_reg;

303✔

11888

   if (kind == T_TYPE_CONV)

303✔

11889

      result_reg = lower_conversion(lu, in_reg, conv, src_type, conv_type);

24✔

11891

      tree_t fdecl = tree_ref(conv);

279✔

11893

      type_t p0_type = tree_type(tree_port(fdecl, 0));

279✔

11894

      vcode_reg_t arg_reg = in_reg;

279✔

11895

      if (type_is_array(p0_type))

279✔

11896

         arg_reg = lower_coerce_arrays(lu, src_type, p0_type, in_reg);

78✔

11898

      vcode_type_t vrtype = lower_func_result_type(conv_type);

279✔

11899

      vcode_type_t vrbounds = lower_bounds(conv_type);

279✔

11901

      ident_t func = tree_ident2(fdecl);

279✔

11902

      vcode_reg_t context_reg = lower_context_for_call(lu, func);

279✔

11903

      vcode_reg_t args[] = { context_reg, arg_reg };

279✔

11904

      result_reg = emit_fcall(func, vrtype, vrbounds, args, 2);

279✔

11906

      if (type_is_array(dst_type)) {

279✔

11907

         vcode_reg_t locus = lower_debug_locus(conv);

69✔

11908

         lower_check_array_sizes(lu, dst_type, conv_type, target_reg,

69✔

11913

   if (type_is_homogeneous(dst_type)) {

303✔

11914

      vcode_reg_t count_reg, data_reg = result_reg, nets_reg = target_reg;

255✔

11915

      if (type_is_array(dst_type)) {

255✔

11916

         count_reg = lower_array_total_len(lu, dst_type, target_reg);

48✔

11917

         data_reg = lower_array_data(result_reg);

48✔

11918

         nets_reg = lower_array_data(target_reg);

48✔

11921

         count_reg = emit_const(voffset, 1);

207✔

11923

      emit_put_conversion(cf_reg, nets_reg, count_reg, data_reg);

255✔

11926

      vcode_reg_t locus = lower_debug_locus(conv);

48✔

11927

      lower_for_each_field_2(lu, dst_type, conv_type, target_reg,

48✔

11929

                             (void *)(uintptr_t)cf_reg);

48✔

11932

   emit_return(emit_const(voffset, 0));

303✔

11934

   unit_registry_finalise(parent->registry, lu);

303✔

11936

   vcode_state_restore(&state);

303✔

11938

   vcode_reg_t context_reg = lower_context_for_call(parent, name);

303✔

11939

   vcode_reg_t vdummy = vtype_opaque();

303✔

11940

   return emit_closure(name, context_reg, vdummy, vdummy);

303✔

11943

static void lower_map_signal_field_cb(lower_unit_t *lu, tree_t field,

1,493✔

11947

   type_t ftype = tree_type(field);

1,493✔

11949

   if (type_is_homogeneous(ftype)) {

1,493✔

11950

      vcode_reg_t dst_reg = emit_load_indirect(dst_ptr);

1,483✔

11952

      vcode_reg_t src_reg;

1,483✔

11953

      if (lower_have_signal(src_ptr))

1,483✔

11954

         src_reg = emit_load_indirect(src_ptr);

1,444✔

11955

      else if (have_uarray_ptr(src_ptr))

39✔

11960

      if (type_is_array(ftype))

1,483✔

11961

         lower_check_array_sizes(lu, ftype, ftype, src_reg, dst_reg, locus);

161✔

11963

      vcode_reg_t count_reg = lower_type_width(lu, ftype, dst_reg);

1,483✔

11965

      src_reg = lower_array_data(src_reg);

1,483✔

11966

      dst_reg = lower_array_data(dst_reg);

1,483✔

11968

      if (lower_have_signal(src_reg))

1,483✔

11969

         emit_map_signal(src_reg, dst_reg, count_reg);

1,444✔

11971

         emit_map_const(src_reg, dst_reg, count_reg);

39✔

11974

      lower_for_each_field_2(lu, ftype, ftype, src_ptr, dst_ptr, locus,

10✔

11976

1,493✔

11978

static void lower_map_view_field_cb(lower_unit_t *lu, tree_t field,

114✔

11982

   tree_t view = untag_pointer(__ctx, void);

114✔

11983

   bool converse = !!pointer_tag(__ctx);

114✔

11985

   tree_t elem = find_element_mode_indication(view, field, &converse);

114✔

11986

   assert(elem != NULL);

114✔

11988

   type_t ftype = tree_type(field);

114✔

11989

   if (type_is_homogeneous(ftype)) {

114✔

11990

      vcode_reg_t src_reg = emit_load_indirect(src_ptr);

99✔

11991

      vcode_reg_t dst_reg = emit_load_indirect(dst_ptr);

99✔

11993

      if (type_is_array(ftype))

99✔

11994

         lower_check_array_sizes(lu, ftype, ftype, src_reg, dst_reg, locus);

20✔

11996

      vcode_reg_t count_reg = lower_type_width(lu, ftype, src_reg);

99✔

11998

      vcode_reg_t src_nets = lower_array_data(src_reg);

99✔

11999

      vcode_reg_t dst_nets = lower_array_data(dst_reg);

99✔

12001

      switch (converse_mode(elem, converse)) {

99✔

12002

      case PORT_IN:

45✔

12003

         emit_map_signal(dst_nets, src_nets, count_reg);

45✔

12004

         break;

45✔

12005

      case PORT_OUT:

54✔

12008

         emit_map_signal(src_nets, dst_nets, count_reg);

54✔

12009

         break;

54✔

12014

   else if (tree_subkind(elem) == PORT_RECORD_VIEW) {

15✔

12015

      void *new_ctx = tag_pointer(tree_value(elem), converse);

6✔

12016

      lower_for_each_field_2(lu, ftype, ftype, src_ptr, dst_ptr, locus,

6✔

12019

   else if (converse_mode(elem, converse) == PORT_IN)

9✔

12020

      lower_for_each_field_2(lu, ftype, ftype, dst_ptr, src_ptr, locus,

6✔

12023

      lower_for_each_field_2(lu, ftype, ftype, src_ptr, dst_ptr, locus,

3✔

12025

114✔

12027

static void lower_map_signal(lower_unit_t *lu, vcode_reg_t src_reg,

4,240✔

12031

   if (!type_is_homogeneous(src_type)) {

4,240✔

12032

      vcode_reg_t locus = lower_debug_locus(where);

295✔

12033

      lower_for_each_field_2(lu, src_type, dst_type, src_reg, dst_reg, locus,

295✔

12036

   else if (type_is_array(src_type)) {

3,945✔

12037

      vcode_reg_t locus = lower_debug_locus(where);

1,251✔

12038

      lower_check_array_sizes(lu, dst_type, src_type, dst_reg, src_reg, locus);

1,251✔

12040

      vcode_reg_t src_nets = lower_array_data(src_reg);

1,251✔

12041

      vcode_reg_t dst_nets = lower_array_data(dst_reg);

1,251✔

12043

      vcode_reg_t count_reg = lower_array_total_len(lu, dst_type, dst_reg);

1,251✔

12045

      if (lower_have_signal(src_reg))

1,251✔

12046

         emit_map_signal(src_nets, dst_nets, count_reg);

1,161✔

12048

         emit_map_const(src_nets, dst_nets, count_reg);

90✔

12051

      vcode_reg_t count_reg = emit_const(vtype_offset(), 1);

2,694✔

12052

      vcode_reg_t dst_nets = lower_array_data(dst_reg);

2,694✔

12054

      if (lower_have_signal(src_reg))

2,694✔

12055

         emit_map_signal(src_reg, dst_nets, count_reg);

2,607✔

12057

         emit_map_const(src_reg, dst_nets, count_reg);

87✔

12059

4,240✔

12061

static void lower_convert_signal_field_cb(lower_unit_t *lu, tree_t field,

291✔

12066

   type_t ftype = tree_type(field);

291✔

12067

   void (*emit_fn)(vcode_reg_t, vcode_reg_t, vcode_reg_t) = ctx;

291✔

12069

   if (type_is_homogeneous(ftype)) {

291✔

12070

      vcode_reg_t nets_reg = emit_load_indirect(src_ptr);

291✔

12071

      vcode_reg_t count_reg = lower_type_width(lu, ftype, nets_reg);

291✔

12072

      vcode_reg_t data_reg = lower_array_data(nets_reg);

291✔

12073

      (*emit_fn)(conv_func, data_reg, count_reg);

291✔

12078

291✔

12080

static void lower_convert_signal(lower_unit_t *lu, vcode_reg_t src_reg,

570✔

12084

   if (!type_is_homogeneous(type))

570✔

12085

      lower_for_each_field(lu, type, src_reg, conv_func,

93✔

12087

   else if (type_is_array(type)) {

477✔

12088

      vcode_reg_t count_reg = lower_array_total_len(lu, type, src_reg);

102✔

12089

      vcode_reg_t nets_reg = lower_array_data(src_reg);

102✔

12090

      (*emit_fn)(conv_func, nets_reg, count_reg);

102✔

12093

      vcode_reg_t count_reg = emit_const(vtype_offset(), 1);

375✔

12094

      vcode_reg_t nets_reg = lower_array_data(src_reg);

375✔

12095

      (*emit_fn)(conv_func, nets_reg, count_reg);

375✔

12097

570✔

12099

static void lower_inertial_actual(lower_unit_t *parent, tree_t dst,

28✔

12106

   assert(standard() >= STD_08);

28✔

12108

   ident_t name;

28✔

12109

   if (tree_kind(dst) == T_PORT_DECL)

28✔

12110

      name = ident_sprintf("%s_actual", istr(tree_ident(dst)));

19✔

12112

      name = ident_uniq("%s_actual.part", istr(tree_ident(name_to_ref(dst))));

9✔

12114

   vcode_type_t signal_type = lower_signal_type(type);

28✔

12115

   vcode_type_t vbounds = lower_bounds(type);

28✔

12116

   vcode_var_t var = emit_var(signal_type, vbounds, name, VAR_SIGNAL);

28✔

12118

   if (type_is_record(type)) {

28✔

12119

      vcode_reg_t locus = lower_debug_locus(dst);

3✔

12120

      vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG);

3✔

12121

      lower_copy_record(parent, type, ptr_reg, port_reg, locus);

3✔

12124

      emit_store(port_reg, var);

25✔

12126

   tree_t expr = tree_value(actual);

28✔

12127

   tree_t target = tree_target(actual);

28✔

12129

   vcode_state_t state;

28✔

12130

   vcode_state_save(&state);

28✔

12132

   ident_t pname = ident_prefix(parent->name, name, '.');

28✔

12133

   vcode_unit_t vu = emit_process(pname, tree_to_object(actual), parent->vunit);

28✔

12135

   lower_unit_t *lu = lower_unit_new(parent->registry, parent, vu, NULL, NULL);

28✔

12136

   unit_registry_put(parent->registry, lu);

28✔

12139

   vcode_block_t main_bb = emit_block();

28✔

12140

   assert(main_bb == 1);

28✔

12142

   if (tree_global_flags(actual) & TREE_GF_EXTERNAL_NAME)

28✔

12143

      tree_visit_only(actual, lower_external_name_cache, lu, T_EXTERNAL_NAME);

1✔

12145

   if (type_is_homogeneous(type)) {

28✔

12146

      vcode_reg_t nets_reg = emit_load_indirect(emit_var_upref(1, var));

25✔

12147

      vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg);

25✔

12148

      vcode_reg_t data_reg = lower_array_data(nets_reg);

25✔

12150

      emit_drive_signal(data_reg, count_reg);

25✔

12153

      vcode_reg_t ptr_reg = emit_var_upref(1, var);

3✔

12154

      lower_for_each_field(lu, type, ptr_reg, VCODE_INVALID_REG,

3✔

12158

   build_wait(expr, lower_build_wait_cb, lu);

28✔

12160

   emit_return(VCODE_INVALID_REG);

28✔

12162

   vcode_select_block(main_bb);

28✔

12164

   vcode_reg_t zero_time_reg = emit_const(vtype_time(), 0);

28✔

12165

   vcode_reg_t value_reg = lower_rvalue(lu, expr);

28✔

12166

   vcode_reg_t nets_reg = emit_var_upref(1, var);

28✔

12168

   if (!type_is_record(type))

28✔

12169

      nets_reg = emit_load_indirect(nets_reg);

25✔

12171

   target_part_t parts[] = {

28✔

12182

   target_part_t *ptr = parts;

28✔

12183

   lower_signal_assign_target(lu, &ptr, target, value_reg, tree_type(expr),

28✔

12186

   emit_return(VCODE_INVALID_REG);

28✔

12188

   unit_registry_finalise(parent->registry, lu);

28✔

12190

   vcode_state_restore(&state);

28✔

12192

   emit_process_init(pname, lower_debug_locus(actual));

28✔

12193

28✔

12195

static void lower_port_map(lower_unit_t *lu, tree_t block, tree_t map,

5,119✔

12198

   vcode_reg_t port_reg = VCODE_INVALID_REG;

5,119✔

12199

   tree_t view = NULL, name;

5,119✔

12200

   vcode_reg_t out_conv = VCODE_INVALID_REG;

5,119✔

12201

   vcode_reg_t in_conv = VCODE_INVALID_REG;

5,119✔

12202

   tree_t value = tree_value(map);

5,119✔

12203

   port_mode_t mode = PORT_IN;

5,119✔

12205

   tree_t value_conv = NULL;

5,119✔

12206

   const tree_kind_t value_kind = tree_kind(value);

5,119✔

12207

   if (value_kind == T_CONV_FUNC || value_kind == T_TYPE_CONV) {

5,119✔

12208

      assert(value_reg == VCODE_INVALID_REG);

203✔

12209

      tree_t p0 = tree_value(value);

203✔

12210

      if (lower_is_signal_ref(p0)) {

203✔

12211

         value_conv = p0;

203✔

12212

         value_reg = lower_lvalue(lu, p0);

203✔

12218

   switch (tree_subkind(map)) {

5,119✔

12219

   case P_POS:

4,416✔

12221

         tree_t port = name = tree_port(block, tree_pos(map));

4,416✔

12222

         mode = tree_subkind(port);

4,416✔

12224

         if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW)

4,416✔

12225

            view = tree_value(port);

38✔

12227

         int hops;

4,416✔

12228

         vcode_var_t var = lower_get_var(lu, port, &hops);

4,416✔

12229

         assert(hops == 0);

4,416✔

12231

         if (type_is_homogeneous(tree_type(port)))

4,416✔

12232

            port_reg = emit_load(var);

4,011✔

12234

            port_reg = emit_index(var, VCODE_INVALID_REG);

405✔

12236

      break;

4,416✔

12237

   case P_NAMED:

703✔

12239

         name = tree_name(map);

703✔

12241

         const tree_kind_t kind = tree_kind(name);

703✔

12242

         if (kind == T_CONV_FUNC || kind == T_TYPE_CONV) {

703✔

12243

            tree_t p0 = tree_value(name);

107✔

12244

            out_conv = lower_converter(lu, value_conv ?: value, p0,

107✔

12246

            name = p0;

107✔

12249

         tree_t port = tree_ref(name_to_ref(name));

703✔

12250

         mode = tree_subkind(port);

703✔

12252

         if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) {

703✔

12253

            view = tree_value(port);

18✔

12256

            bool converse = false;

18✔

12257

            for (tree_t it = name; tree_kind(name) == T_RECORD_REF;

18✔

12259

               tree_t elem = find_element_mode_indication(view, tree_ref(it),

12✔

12261

               assert(elem != NULL);

12✔

12263

               mode = converse_mode(elem, converse);

12✔

12265

               if (mode != PORT_ARRAY_VIEW && mode != PORT_RECORD_VIEW)

12✔

12272

         port_reg = lower_lvalue(lu, name);

703✔

12274

      break;

703✔

12279

   if (value_conv != NULL) {

5,119✔

12281

      in_conv = lower_converter(lu, name, value_conv, value, PORT_IN);

203✔

12282

      value = value_conv;

203✔

12285

   if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) {

5,119✔

12286

      assert(lower_is_signal_ref(value));

44✔

12287

      vcode_reg_t locus = lower_debug_locus(view);

44✔

12288

      lower_for_each_field_2(lu, tree_type(name), tree_type(value), port_reg,

44✔

12291

   else if (lower_is_signal_ref(value)) {

5,075✔

12292

      type_t value_type = tree_type(value);

4,342✔

12293

      type_t name_type = tree_type(name);

4,342✔

12295

      vcode_reg_t src_reg = mode == PORT_IN ? value_reg : port_reg;

4,342✔

12296

      vcode_reg_t dst_reg = mode == PORT_IN ? port_reg : value_reg;

4,342✔

12297

      vcode_reg_t conv_func = mode == PORT_IN ? in_conv : out_conv;

4,342✔

12299

      type_t src_type = mode == PORT_IN ? value_type : name_type;

4,342✔

12300

      type_t dst_type = mode == PORT_IN ? name_type : value_type;

4,342✔

12302

      if (conv_func != VCODE_INVALID_REG) {

4,342✔

12303

         vcode_reg_t conv_reg = emit_port_conversion(conv_func, in_conv);

285✔

12304

         lower_convert_signal(lu, dst_reg, dst_type,

285✔

12306

         lower_convert_signal(lu, src_reg, src_type,

285✔

12310

         lower_map_signal(lu, src_reg, dst_reg, src_type, dst_type, map);

4,057✔

12312

   else if (tree_kind(value) == T_INERTIAL)

733✔

12313

      lower_inertial_actual(lu, name, tree_type(name), port_reg, value);

28✔

12314

   else if (value_reg != VCODE_INVALID_REG) {

705✔

12315

      type_t value_type = tree_type(value);

183✔

12316

      type_t name_type = tree_type(name);

183✔

12317

      lower_map_signal(lu, value_reg, port_reg, value_type, name_type, map);

183✔

12319

5,119✔

12321

static void lower_direct_mapped_port(lower_unit_t *lu, driver_set_t *ds,

9,573✔

12325

   tree_t port = NULL;

9,573✔

12326

   int field = -1;

9,573✔

12327

   switch (tree_subkind(map)) {

9,573✔

12328

   case P_POS:

8,843✔

12329

      port = tree_port(block, tree_pos(map));

8,843✔

12330

      break;

8,843✔

12331

   case P_NAMED:

730✔

12333

         tree_t name = tree_name(map);

730✔

12334

         tree_kind_t kind = tree_kind(name);

730✔

12336

         if (kind == T_RECORD_REF) {

730✔

12337

            field = tree_pos(tree_ref(name));

380✔

12338

            name  = tree_value(name);

380✔

12339

            kind  = tree_kind(name);

380✔

12342

         if (kind != T_REF)

730✔

12343

            return;

5,116✔

12345

         port = tree_ref(name);

472✔

12347

      break;

472✔

12350

   assert(tree_kind(port) == T_PORT_DECL);

9,315✔

12352

   tree_t value = tree_value(map);

9,315✔

12354

   if (tree_class(port) == C_VARIABLE) {

9,315✔

12357

      vcode_type_t vtype = lower_type(tree_type(port));

3✔

12358

      vcode_var_t var = emit_var(vtype, vtype, tree_ident(port), 0);

3✔

12359

      lower_put_vcode_obj(port, var, lu);

3✔

12361

      vcode_reg_t src_reg = lower_rvalue(lu, value);

3✔

12362

      emit_store(src_reg, var);

3✔

12364

      hset_insert(direct, map);

3✔

12365

      hset_insert(direct, port);

3✔

12366

      return;

3✔

12368

   else if (tree_subkind(port) != PORT_IN)

9,312✔

12370

   else if (!lower_is_signal_ref(value) || tree_kind(value) == T_TYPE_CONV) {

5,297✔

12371

      if (field != -1) {

528✔

12374

         if (*poison == NULL)

9✔

12375

            *poison = hset_new(32);

6✔

12376

         hset_insert(*poison, port);

9✔

12378

      return;

528✔

12380

   else if (*poison != NULL && hset_contains(*poison, port))

4,769✔

12383

   type_t type = tree_type(value);

4,763✔

12384

   type_t port_type = tree_type(port);

4,763✔

12386

   if (type_is_unconstrained(port_type))

4,763✔

12389

   int hops = 0;

4,457✔

12390

   vcode_var_t var = lower_search_vcode_obj(port, lu, &hops);

4,457✔

12391

   assert(var != VCODE_INVALID_VAR);

4,457✔

12392

   assert(hops == 0);

4,457✔

12394

   type_t field_type = port_type;

4,457✔

12395

   if (field != -1) {

4,457✔

12396

      tree_t f = type_field(port_type, field);

23✔

12397

      tree_t cons = type_constraint_for_field(port_type, f);

23✔

12398

      field_type = tree_type(cons ?: f);

41✔

12399

      port_type = tree_type(f);

23✔

12402

   vcode_reg_t bounds_reg = VCODE_INVALID_REG;

4,457✔

12403

   if (!type_const_bounds(field_type))

4,457✔

12404

      bounds_reg = lower_get_type_bounds(lu, field_type);

157✔

12406

   if (type_is_array(type)) {

4,457✔

12407

      vcode_reg_t locus = lower_debug_locus(map);

415✔

12408

      lower_check_array_sizes(lu, field_type, type, bounds_reg, src_reg, locus);

415✔

12411

   if (field != -1) {

4,457✔

12412

      vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG);

23✔

12413

      vcode_reg_t field_reg = emit_record_ref(ptr_reg, field);

23✔

12415

      if (type_is_record(type))

23✔

12417

      else if (type_is_array(type)) {

23✔

12418

         if (type_is_homogeneous(type)){

9✔

12419

            vcode_reg_t coerce_reg =

9✔

12420

               lower_coerce_arrays(lu, type, port_type, src_reg);

9✔

12421

            emit_store_indirect(coerce_reg, field_reg);

9✔

12430

         emit_store_indirect(src_reg, field_reg);

14✔

12432

   else if (type_is_record(type)) {

4,434✔

12433

      vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG);

131✔

12434

      emit_copy(ptr_reg, src_reg, VCODE_INVALID_REG);

131✔

12436

   else if (type_is_array(type)) {

4,303✔

12437

      vcode_reg_t data_reg = lower_array_data(src_reg);

406✔

12439

      if (vcode_reg_kind(data_reg) == VCODE_TYPE_SIGNAL)

406✔

12440

         emit_alias_signal(data_reg, lower_debug_locus(port));

305✔

12442

      if (bounds_reg != VCODE_INVALID_REG) {

406✔

12443

         vcode_reg_t wrap_reg = lower_rewrap(data_reg, bounds_reg);

153✔

12444

         emit_store(wrap_reg, var);

153✔

12446

      else if (!type_is_homogeneous(type)) {

253✔

12447

         vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG);

7✔

12448

         vcode_reg_t count_reg = lower_array_total_len(lu, type, src_reg);

7✔

12449

         emit_copy(ptr_reg, data_reg, count_reg);

7✔

12452

         emit_store(data_reg, var);

246✔

12455

      emit_alias_signal(src_reg, lower_debug_locus(port));

3,897✔

12456

      emit_store(src_reg, var);

3,897✔

12459

   hset_insert(direct, map);

4,457✔

12460

   hset_insert(direct, port);

4,457✔

12463

static void lower_port_signal(lower_unit_t *lu, tree_t port,

4,739✔

12466

   type_t type = tree_type(port);

4,739✔

12467

   type_t value_type = type;

4,739✔

12469

   const port_mode_t mode = tree_subkind(port);

4,739✔

12470

   tree_t view = NULL;

4,739✔

12471

   vcode_reg_t init_reg = VCODE_INVALID_REG;

4,739✔

12472

   if (mode == PORT_RECORD_VIEW || mode == PORT_ARRAY_VIEW) {

4,739✔

12474

      view = tree_value(port);

50✔

12476

   else if (tree_has_value(port)) {

4,689✔

12477

      tree_t value = tree_value(port);

275✔

12478

      value_type = tree_type(value);

275✔

12479

      init_reg = lower_rvalue(lu, value);

275✔

12482

   sig_flags_t flags = 0;

4,739✔

12483

   if (tree_flags(port) & TREE_F_REGISTER)

4,739✔

12488

   if (mode == PORT_INOUT)

4,739✔

12489

      flags |= NET_F_EFFECTIVE | NET_F_INOUT;

258✔

12491

   lower_sub_signals(lu, type, type, value_type, port, view, var,

4,739✔

12494

4,739✔

12496

static vcode_reg_t lower_constrain_port(lower_unit_t *lu, tree_t port, int pos,

177✔

12499

   vcode_reg_t left_reg = VCODE_INVALID_REG, right_reg = VCODE_INVALID_REG;

177✔

12500

   type_t port_type = tree_type(port);

177✔

12502

   vcode_reg_t rptr_reg = VCODE_INVALID_VAR;

177✔

12503

   if (type_is_record(port_type)) {

177✔

12504

      vcode_type_t vtype = lower_signal_type(port_type);

70✔

12505

      ident_t name = ident_prefix(tree_ident(port), ident_new("cons"), '$');

70✔

12506

      vcode_var_t rec_var = emit_var(vtype, vtype, name, 0);

70✔

12507

      rptr_reg = emit_index(rec_var, VCODE_INVALID_REG);

70✔

12510

   const int nparams = tree_params(block);

177✔

12511

   for (int i = 0; i < nparams; i++) {

1,493✔

12512

      tree_t map = tree_param(block, i), name = NULL;

1,447✔

12513

      switch (tree_subkind(map)) {

1,447✔

12514

      case P_POS:

303✔

12515

         if (tree_pos(map) != pos)

303✔

12516

            continue;

176✔

12519

      case P_NAMED:

1,144✔

12521

            tree_t ref = name_to_ref((name = tree_name(map)));

1,144✔

12522

            if (ref == NULL || tree_ref(ref) != port)

1,144✔

12523

               continue;

800✔

12528

      vcode_reg_t bounds_reg;

471✔

12529

      if (map_regs[i] == VCODE_INVALID_REG) {

471✔

12531

         tree_t value = tree_value(map);

3✔

12532

         assert(tree_kind(value) == T_CONV_FUNC);

3✔

12535

         type_t type = tree_type(value);

3✔

12536

         if (type_is_record(type))

3✔

12537

            bounds_reg = lower_default_value(lu, type, VCODE_INVALID_REG);

3✔

12544

      if (name == NULL || tree_kind(name) == T_REF) {

471✔

12545

         type_t value_type = tree_type(tree_value(map));

131✔

12546

         if (type_is_array(port_type))

131✔

12547

            return lower_coerce_arrays(lu, value_type, port_type, bounds_reg);

94✔

12552

      switch (tree_kind(name)) {

340✔

12553

      case T_ARRAY_REF:

16✔

12557

            tree_t value = tree_value(tree_param(name, 0));

16✔

12559

            if (left_reg == VCODE_INVALID_REG)

16✔

12560

               left_reg = right_reg = lower_rvalue(lu, value);

13✔

12562

               vcode_reg_t value_reg = lower_rvalue(lu, value);

3✔

12563

               vcode_reg_t below_reg =

3✔

12564

                  emit_cmp(VCODE_CMP_LT, value_reg, left_reg);

3✔

12565

               vcode_reg_t above_reg =

3✔

12566

                  emit_cmp(VCODE_CMP_GT, value_reg, right_reg);

3✔

12568

               left_reg = emit_select(below_reg, value_reg, left_reg);

3✔

12569

               right_reg = emit_select(above_reg, value_reg, right_reg);

3✔

12574

      case T_RECORD_REF:

324✔

12576

            tree_t f = tree_ref(name);

324✔

12577

            assert(tree_kind(f) == T_FIELD_DECL);

324✔

12579

            type_t ftype = tree_type(f);

324✔

12580

            if (!type_is_unconstrained(ftype))

324✔

12581

               continue;

216✔

12583

            type_t value_type = tree_type(tree_value(map));

108✔

12585

            vcode_reg_t value_reg;

108✔

12586

            if (type_is_array(ftype))

108✔

12587

               value_reg = lower_coerce_arrays(lu, value_type, ftype,

108✔

12592

            vcode_reg_t field_reg = emit_record_ref(rptr_reg, tree_pos(f));

108✔

12593

            emit_store_indirect(value_reg, field_reg);

108✔

12595

         break;

108✔

12605

   if (rptr_reg != VCODE_INVALID_REG)

46✔

12608

      assert(left_reg != VCODE_INVALID_REG);

13✔

12610

      type_t elem = type_elem_recur(port_type);

13✔

12611

      vcode_type_t velem = lower_type(elem);

13✔

12613

      vcode_reg_t dir_reg = emit_const(vtype_bool(), RANGE_TO);

13✔

12614

      vcode_reg_t null_reg = emit_null(vtype_pointer(velem));

13✔

12615

      vcode_dim_t dims[] = {

13✔

12618

      return emit_wrap(null_reg, dims, 1);

13✔

12622

static vcode_reg_t lower_open_port_map(lower_unit_t *lu, tree_t block, tree_t p)

547✔

12624

   tree_t port;

547✔

12625

   if (tree_subkind(p) == P_NAMED) {

547✔

12626

      tree_t name = tree_name(p);

7✔

12627

      if (tree_kind(name) == T_REF)

7✔

12628

         port = tree_ref(name);

1✔

12631

         assert(standard() >= STD_19);

6✔

12636

      port = tree_port(block, tree_pos(p));

540✔

12638

   if (tree_has_value(port)) {

541✔

12639

      tree_t def = tree_value(port);

25✔

12640

      vcode_reg_t def_reg = lower_rvalue(lu, def);

25✔

12642

      type_t port_type = tree_type(port);

25✔

12643

      if (type_is_array(port_type))

25✔

12644

         return lower_coerce_arrays(lu, tree_type(def), port_type, def_reg);

14✔

12652

static void lower_ports(lower_unit_t *lu, driver_set_t *ds, tree_t block)

9,410✔

12654

   const int nports = tree_ports(block);

9,410✔

12655

   const int nparams = tree_params(block);

9,410✔

12657

   hset_t *direct = hset_new(nports * 2), *poison = NULL;

9,410✔

12658

   vcode_reg_t *map_regs LOCAL = xmalloc_array(nparams, sizeof(vcode_reg_t));

18,820✔

12659

   vcode_var_t *port_vars LOCAL = xmalloc_array(nports, sizeof(vcode_var_t));

18,820✔

12661

   for (int i = 0; i < nparams; i++) {

18,989✔

12662

      tree_t p = tree_param(block, i);

9,579✔

12664

      tree_t value = tree_value(p);

9,579✔

12665

      const tree_kind_t kind = tree_kind(value);

9,579✔

12666

      if (kind == T_TYPE_CONV || kind == T_CONV_FUNC || kind == T_INERTIAL)

9,579✔

12667

         map_regs[i] = VCODE_INVALID_REG;

231✔

12668

      else if (lower_is_signal_ref(value))

9,348✔

12669

         map_regs[i] = lower_lvalue(lu, value);

8,640✔

12670

      else if (tree_kind(value) == T_OPEN)

708✔

12671

         map_regs[i] = lower_open_port_map(lu, block, p);

547✔

12673

         map_regs[i] = lower_rvalue(lu, value);

161✔

12676

   for (int i = 0; i < nports; i++) {

18,595✔

12677

      tree_t port = tree_port(block, i);

9,185✔

12678

      type_t type = tree_type(port);

9,185✔

12680

      vcode_type_t vtype = lower_signal_type(type);

9,185✔

12681

      port_vars[i] = emit_var(vtype, vtype, tree_ident(port), VAR_SIGNAL);

9,185✔

12682

      lower_put_vcode_obj(port, port_vars[i], lu);

9,185✔

12685

   if (!opt_get_int(OPT_NO_COLLAPSE)) {

9,410✔

12688

      for (int i = 0; i < nparams; i++)

18,977✔

12689

         lower_direct_mapped_port(lu, ds, block, tree_param(block, i), direct,

9,573✔

12690

                                  &poison, map_regs[i]);

9,573✔

12693

   for (int i = 0; i < nports; i++) {

18,595✔

12694

      tree_t port = tree_port(block, i);

9,185✔

12695

      type_t type = tree_type(port);

9,185✔

12697

      vcode_reg_t bounds_reg = VCODE_INVALID_REG;

9,185✔

12698

      if (type_is_unconstrained(type))

9,185✔

12699

         bounds_reg = lower_constrain_port(lu, port, i, block, map_regs);

177✔

12700

      else if (!type_const_bounds(type))

9,008✔

12701

         bounds_reg = lower_get_type_bounds(lu, type);

539✔

12703

      if (!hset_contains(direct, port))

9,185✔

12704

         lower_port_signal(lu, port, port_vars[i], bounds_reg);

4,739✔

12705

      else if (poison != NULL && hset_contains(poison, port))

4,446✔

12709

   for (int i = 0; i < nparams; i++) {

18,989✔

12710

      tree_t map = tree_param(block, i);

9,579✔

12711

      if (!hset_contains(direct, map))

9,579✔

12712

         lower_port_map(lu, block, map, map_regs[i]);

5,119✔

12713

      else if (poison != NULL && tree_subkind(map) == P_NAMED) {

4,460✔

12720

   if (cover_enabled(lu->cover, COVER_MASK_TOGGLE)) {

9,410✔

12721

      for (int i = 0; i < nports; i++) {

382✔

12722

         tree_t p = tree_port(block, i);

112✔

12723

         PUSH_COVER_SCOPE(lu, p);

224✔

12724

         lower_toggle_coverage(lu, p);

112✔

12728

   hset_free(direct);

9,410✔

12729

   if (poison != NULL)

9,410✔

12730

      hset_free(poison);

6✔

12731

9,410✔

12733

static void lower_check_generic_constraint(lower_unit_t *lu, tree_t expect,

17✔

12736

   vcode_reg_t expect_reg = lower_rvalue(lu, expect);

17✔

12737

   if (expect_reg == VCODE_INVALID_REG)

17✔

12738

      return;   // Was OPEN

1✔

12740

   int hops;

16✔

12741

   vcode_var_t actual_var = lower_get_var(lu, generic, &hops);

16✔

12742

   assert(actual_var != VCODE_INVALID_VAR);

16✔

12743

   assert(hops == 0);

16✔

12745

   type_t type = tree_type(expect);

16✔

12747

   vcode_reg_t test_reg;

16✔

12748

   if (type_is_scalar(type)) {

16✔

12749

      vcode_reg_t actual_reg = emit_load(actual_var);

11✔

12750

      test_reg = emit_cmp(VCODE_CMP_EQ, expect_reg, actual_reg);

11✔

12753

      vcode_reg_t actual_reg;

5✔

12754

      if (vtype_kind(vcode_var_type(actual_var)) == VCODE_TYPE_UARRAY)

5✔

12757

         actual_reg = emit_index(actual_var, VCODE_INVALID_REG);

5✔

12759

      vcode_reg_t left_reg = actual_reg, right_reg = expect_reg;

5✔

12760

      if (type_is_array(type)) {

5✔

12761

         left_reg = lower_wrap(lu, type, actual_reg);

3✔

12762

         right_reg = lower_wrap(lu, type, expect_reg);

3✔

12765

      ident_t func = lower_predef_func_name(type, "=");

5✔

12766

      vcode_reg_t context_reg = lower_context_for_call(lu, func);

5✔

12767

      vcode_reg_t args[] = { context_reg, left_reg, right_reg };

5✔

12768

      vcode_type_t vbool = vtype_bool();

5✔

12769

      test_reg = emit_fcall(func, vbool, vbool, args, 3);

5✔

12772

   vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1);

16✔

12773

   vcode_reg_t error_reg = emit_const(vseverity, SEVERITY_ERROR);

16✔

12775

   emit_assert(test_reg, VCODE_INVALID_REG, VCODE_INVALID_REG, error_reg,

16✔

12779

static void lower_pack_inst_generics(lower_unit_t *lu, tree_t inst, tree_t map)

80✔

12781

   int hops = 0;

80✔

12782

   vcode_reg_t var = lower_search_vcode_obj(inst, lu, &hops);

80✔

12784

   vcode_reg_t context;

80✔

12785

   if (var == VCODE_INVALID_VAR)

80✔

12786

      context = emit_link_package(tree_ident(inst));

14✔

12788

      context = emit_load_indirect(emit_var_upref(hops, var));

66✔

12790

   const int ngenerics = tree_generics(inst);

80✔

12791

   for (int i = 0; i < ngenerics; i++) {

357✔

12792

      tree_t g = tree_generic(inst, i);

277✔

12793

      if (tree_class(g) != C_CONSTANT)

277✔

12794

         continue;

162✔

12796

      type_t type = tree_type(g);

115✔

12797

      vcode_type_t vtype = lower_type(type);

115✔

12798

      vcode_type_t vbounds = lower_bounds(type);

115✔

12800

      ident_t name = tree_ident(g);

115✔

12801

      vcode_var_t var = emit_var(vtype, vbounds, name, VAR_CONST);

115✔

12803

      vcode_reg_t ptr_reg = emit_link_var(context, name, vtype);

115✔

12805

      if (type_is_scalar(type))

115✔

12806

         emit_store(emit_load_indirect(ptr_reg), var);

109✔

12807

      else if (type_is_array(type)) {

6✔

12808

         if (type_const_bounds(type)) {

4✔

12809

            vcode_reg_t count_reg = lower_array_total_len(lu, type, ptr_reg);

4✔

12810

            vcode_reg_t dest_reg = emit_index(var, VCODE_INVALID_REG);

4✔

12811

            vcode_reg_t src_reg = lower_array_data(ptr_reg);

4✔

12812

            emit_copy(dest_reg, src_reg, count_reg);

4✔

12816

         vcode_reg_t dest_reg = emit_index(var, VCODE_INVALID_REG);

2✔

12817

         emit_copy(dest_reg, ptr_reg, VCODE_INVALID_REG);

2✔

12820

      lower_put_vcode_obj(g, var, lu);

115✔

12822

      tree_t g0 = tree_generic(tree_ref(inst), i);

115✔

12823

      lower_put_vcode_obj(g0, var, lu);

115✔

12826

   switch (tree_subkind(map)) {

80✔

12827

   case PACKAGE_MAP_MATCHING:

6✔

12829

         const int count = tree_genmaps(map);

6✔

12830

         for (int i = 0; i < count; i++) {

16✔

12831

            tree_t m = tree_genmap(map, i);

10✔

12832

            assert(tree_subkind(m) == P_POS);

10✔

12834

            tree_t g = tree_generic(inst, i);

10✔

12836

            vcode_reg_t locus = lower_debug_locus(m);

10✔

12837

            lower_check_generic_constraint(lu, tree_value(m), g, locus);

10✔

12843

      for (int i = 0; i < ngenerics; i++) {

10✔

12844

         tree_t g = tree_generic(inst, i);

7✔

12845

         tree_t g0 = tree_generic(tree_ref(map), i);

7✔

12847

         vcode_reg_t locus = lower_debug_locus(map);

7✔

12848

         lower_check_generic_constraint(lu, tree_value(g0), g, locus);

7✔

12855

80✔

12857

static void lower_generics(lower_unit_t *lu, tree_t block, tree_t primary)

10,124✔

12859

   const int ngenerics = tree_generics(block);

10,124✔

12860

   assert(ngenerics == tree_genmaps(block));

10,124✔

12862

   for (int i = 0; i < ngenerics; i++) {

16,608✔

12863

      tree_t g = tree_generic(block, i);

6,484✔

12864

      tree_t m = tree_genmap(block, i);

6,484✔

12865

      assert(tree_subkind(m) == P_POS);

6,484✔

12867

      const class_t class = tree_class(g);

6,484✔

12868

      if (class == C_PACKAGE) {

6,484✔

12871

         tree_t map = tree_value(g);

80✔

12872

         assert(tree_kind(map) == T_PACKAGE_MAP);

80✔

12874

         tree_t inst = tree_ref(tree_value(m));

80✔

12875

         assert(tree_kind(inst) == T_PACK_INST);

80✔

12877

         lower_pack_inst_generics(lu, inst, map);

80✔

12880

      if (class != C_CONSTANT)

6,484✔

12881

         continue;   // Skip type generics, etc.

1,450✔

12883

      type_t type = tree_type(g);

5,034✔

12885

      vcode_type_t vtype = lower_type(type);

5,034✔

12886

      vcode_type_t vbounds = lower_bounds(type);

5,034✔

12887

      vcode_var_t var = emit_var(vtype, vbounds, tree_ident(g), VAR_CONST);

5,034✔

12889

      vcode_reg_t mem_reg = VCODE_INVALID_REG, count_reg = VCODE_INVALID_REG;

5,034✔

12891

      const bool is_array = type_is_array(type);

5,034✔

12893

      if (is_array && type_const_bounds(type)) {

5,034✔

12894

         mem_reg = emit_index(var, VCODE_INVALID_REG);

166✔

12895

         count_reg = lower_array_total_len(lu, type, VCODE_INVALID_REG);

166✔

12897

      else if (type_is_record(type))

4,868✔

12898

         mem_reg = emit_index(var, VCODE_INVALID_REG);

82✔

12900

      tree_t value = tree_value(m);

5,034✔

12901

      vcode_reg_t value_reg;

5,034✔

12902

      switch (tree_kind(value)) {

5,034✔

12903

      case T_AGGREGATE:

17✔

12904

         value_reg = lower_aggregate(lu, value, mem_reg);

17✔

12905

         break;

17✔

12906

      case T_OPEN:

192✔

12907

         assert(tree_has_value(g));

192✔

12908

         value = tree_value(g);

192✔

12910

      default:

5,017✔

12911

         value_reg = lower_rvalue(lu, value);

5,017✔

12912

         break;

5,017✔

12915

      if (is_array && mem_reg != VCODE_INVALID_REG) {

5,034✔

12916

         vcode_reg_t locus = lower_debug_locus(g);

166✔

12917

         lower_check_array_sizes(lu, type, tree_type(value),

166✔

12920

      else if (type_is_scalar(type))

4,868✔

12921

         lower_check_scalar_bounds(lu, value_reg, type, value, g);

4,596✔

12923

      if (mem_reg != VCODE_INVALID_REG)

5,034✔

12924

         emit_copy(mem_reg, lower_array_data(value_reg), count_reg);

248✔

12925

      else if (is_array) {

4,786✔

12926

         vcode_reg_t wrap_reg = lower_coerce_arrays(lu, tree_type(value),

190✔

12928

         emit_store(wrap_reg, var);

190✔

12931

         emit_store(value_reg, var);

4,596✔

12933

      lower_put_vcode_obj(g, var, lu);

5,034✔

12935

      if (primary != NULL) {

5,034✔

12939

         tree_t g2 = tree_generic(primary, i);

2,434✔

12940

         assert(tree_ident(g2) == tree_ident(g));

2,434✔

12941

         if (g2 != g) lower_put_vcode_obj(g2, var, lu);

2,434✔

12944

10,124✔

12946

static void lower_deps_cb(ident_t unit_name, void *__ctx)

70,330✔

12948

   lower_unit_t *lu = __ctx;

70,330✔

12950

   object_t *obj = lib_load_handler(unit_name);

70,330✔

12952

   tree_t unit = tree_from_object(obj);

70,330✔

12953

   if (unit == NULL)

70,330✔

12956

   const tree_kind_t kind = tree_kind(unit);

70,199✔

12957

   if (kind != T_ENTITY && unit_name == lu->name)

70,199✔

12960

   if (kind == T_PACKAGE && standard() >= STD_08) {

69,021✔

12961

      if (is_uninstantiated_package(unit))

9,029✔

12965

   if (kind == T_PACKAGE || kind == T_PACK_INST)

68,604✔

12966

      emit_package_init(unit_name, VCODE_INVALID_REG);

27,470✔

12969

static void lower_dependencies(lower_unit_t *lu, tree_t unit)

11,041✔

12971

   tree_walk_deps(unit, lower_deps_cb, lu);

24,259✔

12973

   switch (tree_kind(unit)) {

24,259✔

12974

   case T_ARCH:

7,198✔

12976

      lower_dependencies(lu, tree_primary(unit));

7,198✔

12977

      break;

7,198✔

12978

   case T_BLOCK:

9,410✔

12980

         tree_t hier = tree_decl(unit, 0);

9,410✔

12981

         assert(tree_kind(hier) == T_HIER);

9,410✔

12983

         tree_t src = tree_ref(hier);

9,410✔

12984

         if (is_design_unit(src))

9,410✔

12991

11,041✔

12993

static bool lower_push_package_scope(tree_t pack)

2,801✔

12995

   const int ndecls = tree_decls(pack);

2,801✔

12996

   for (int i = 0; i < ndecls; i++) {

191,563✔

12997

      tree_t d = tree_decl(pack, i);

188,807✔

12998

      if (tree_kind(d) == T_SIGNAL_DECL) {

188,807✔

12999

         vcode_reg_t locus = lower_debug_locus(pack);

45✔

13000

         emit_package_scope(locus);

45✔

13001

         return true;

45✔

13008

static void lower_cache_instance_name(lower_unit_t *lu, attr_kind_t which)

812✔

13010

   ident_t name =

812✔

13011

      well_known(which == ATTR_INSTANCE_NAME ? W_INSTANCE_NAME : W_PATH_NAME);

1,265✔

13013

   vcode_type_t vchar = vtype_char();

812✔

13014

   vcode_type_t vstring = vtype_uarray(1, vchar, vchar);

812✔

13015

   vcode_var_t var = emit_var(vstring, vchar, name, VAR_CONST);

812✔

13016

   vcode_reg_t kind_reg = emit_const(vtype_offset(), which);

812✔

13017

   vcode_reg_t str_reg = emit_instance_name(kind_reg);

812✔

13018

   emit_store(str_reg, var);

812✔

13020

   lower_put_vcode_obj(name, var, lu);

812✔

13021

812✔

13023

static void lower_pack_body(lower_unit_t *lu, object_t *obj)

1,178✔

13025

   tree_t body = tree_from_object(obj);

1,178✔

13027

   tree_t pack = tree_primary(body);

1,178✔

13028

   assert(!is_uninstantiated_package(pack));

1,178✔

13030

   if (standard() >= STD_08 && is_well_known(lu->name) == W_IEEE_1164) {

1,178✔

13033

      ident_t ieee_support = ident_new("NVC.IEEE_SUPPORT");

35✔

13034

      emit_package_init(ieee_support, VCODE_INVALID_REG);

35✔

13037

   tree_global_flags_t gflags = tree_global_flags(body);

1,178✔

13038

   gflags |= tree_global_flags(pack);

1,178✔

13040

   if (gflags & TREE_GF_INSTANCE_NAME)

1,178✔

13041

      lower_cache_instance_name(lu, ATTR_INSTANCE_NAME);

20✔

13043

   if (gflags & TREE_GF_PATH_NAME)

1,178✔

13044

      lower_cache_instance_name(lu, ATTR_PATH_NAME);

14✔

13046

   if (gflags & TREE_GF_EXTERNAL_NAME) {

1,178✔

13047

      tree_visit_only(pack, lower_external_name_cache, lu, T_EXTERNAL_NAME);

3✔

13048

      tree_visit_only(body, lower_external_name_cache, lu, T_EXTERNAL_NAME);

3✔

13051

   lower_dependencies(lu, body);

1,178✔

13053

   const bool has_scope =

2,356✔

13054

      lower_push_package_scope(pack) || lower_push_package_scope(body);

1,178✔

13056

   lower_decls(lu, pack);

1,178✔

13057

   lower_decls(lu, body);

1,178✔

13059

   if (has_scope)

1,178✔

13060

      emit_pop_scope();

8✔

13062

   emit_return(VCODE_INVALID_REG);

1,178✔

13063

1,178✔

13065

static void lower_package(lower_unit_t *lu, object_t *obj)

453✔

13067

   tree_t pack = tree_from_object(obj);

453✔

13068

   assert(!is_uninstantiated_package(pack));

453✔

13070

   const tree_global_flags_t gflags = tree_global_flags(pack);

453✔

13072

   if (gflags & TREE_GF_INSTANCE_NAME)

453✔

13073

      lower_cache_instance_name(lu, ATTR_INSTANCE_NAME);

11✔

13075

   if (gflags & TREE_GF_PATH_NAME)

453✔

13076

      lower_cache_instance_name(lu, ATTR_PATH_NAME);

3✔

13078

   if (gflags & TREE_GF_EXTERNAL_NAME)

453✔

13079

      tree_visit_only(pack, lower_external_name_cache, lu, T_EXTERNAL_NAME);

1✔

13081

   lower_dependencies(lu, pack);

453✔

13083

   const bool has_scope = lower_push_package_scope(pack);

453✔

13085

   lower_generics(lu, pack, NULL);

453✔

13086

   lower_decls(lu, pack);

453✔

13088

   if (has_scope)

453✔

13089

      emit_pop_scope();

37✔

13091

   emit_return(VCODE_INVALID_REG);

453✔

13092

453✔

13094

vcode_reg_t lower_lvalue(lower_unit_t *lu, tree_t expr)

49,178✔

13096

   return lower_expr(lu, expr, EXPR_LVALUE);

49,178✔

13099

vcode_reg_t lower_rvalue(lower_unit_t *lu, tree_t expr)

448,641✔

13101

   vcode_reg_t reg = lower_expr(lu, expr, EXPR_RVALUE);

448,641✔

13102

   if (reg == VCODE_INVALID_REG)

448,641✔

13105

   for (;;) {

461,342✔

13106

      switch (vcode_reg_kind(reg)) {

461,342✔

13107

      case VCODE_TYPE_SIGNAL:

11,875✔

13108

         reg = lower_resolved(lu, tree_type(expr), reg);

11,875✔

13109

         continue;

11,875✔

13110

      case VCODE_TYPE_POINTER:

57,000✔

13112

            type_t type = tree_type(expr);

57,000✔

13113

            if (lower_have_signal(reg)) {

57,000✔

13114

               reg = lower_resolved(lu, tree_type(expr), reg);

827✔

13115

               continue;

827✔

13117

            else if (!type_is_composite(type))

56,173✔

13118

               return emit_load_indirect(reg);

19,078✔

13122

      case VCODE_TYPE_UARRAY:

44,812✔

13123

         if (lower_have_signal(reg))

44,812✔

13124

            return lower_resolved(lu, tree_type(expr), reg);

497✔

13133

vcode_unit_t lower_case_generate_thunk(lower_unit_t *parent, tree_t t)

9✔

13137

   vcode_unit_t context = parent ? parent->vunit : NULL;

9✔

13138

   vcode_unit_t thunk = emit_thunk(NULL, tree_to_object(t), context);

9✔

13139

   lower_unit_t *lu = lower_unit_new(parent->registry, parent, thunk, NULL, NULL);

9✔

13141

   vcode_type_t vbool = vtype_bool();

9✔

13142

   vcode_type_t vint = vtype_int(INT32_MIN, INT32_MAX);

9✔

13143

   vcode_set_result(vint);

9✔

13145

   if (parent != NULL) {

9✔

13146

      vcode_type_t vcontext = vtype_context(parent->name);

9✔

13147

      emit_param(vcontext, vcontext, ident_new("context"));

9✔

13150

   tree_t value = tree_value(t);

9✔

13151

   type_t type = tree_type(value);

9✔

13153

   ident_t cmp_func = NULL;

9✔

13154

   if (!type_is_scalar(type))

9✔

13155

      cmp_func = lower_predef_func_name(tree_type(value), "=");

9✔

13157

   vcode_reg_t value_reg = lower_rvalue(lu, value);

9✔

13159

   if (cmp_func != NULL)

9✔

13160

      value_reg = lower_wrap(lu, type, value_reg);

9✔

13162

   const int nstmts = tree_stmts(t);

9✔

13163

   for (int i = 0; i < nstmts; i++) {

45✔

13164

      tree_t alt = tree_stmt(t, i);

36✔

13166

      const int nassocs = tree_assocs(alt);

36✔

13167

      for (int j = 0; j < nassocs; j++) {

72✔

13168

         tree_t a = tree_assoc(alt, j);

36✔

13169

         switch (tree_subkind(a)) {

36✔

13170

         case A_NAMED:

27✔

13172

               tree_t name = tree_name(a);

27✔

13173

               vcode_reg_t name_reg = lower_rvalue(lu, name);

27✔

13174

               vcode_block_t match_bb = emit_block();

27✔

13175

               vcode_block_t skip_bb = emit_block();

27✔

13177

               if (cmp_func != NULL) {

27✔

13178

                  if (vcode_reg_kind(name_reg) != VCODE_TYPE_UARRAY)

27✔

13179

                     name_reg = lower_wrap(lu, tree_type(name), name_reg);

27✔

13181

                  vcode_reg_t context_reg =

27✔

13182

                     lower_context_for_call(lu, cmp_func);

27✔

13183

                  vcode_reg_t args[] = { context_reg, name_reg, value_reg };

27✔

13184

                  vcode_reg_t eq_reg = emit_fcall(cmp_func, vbool, vbool,

27✔

13186

                  emit_cond(eq_reg, match_bb, skip_bb);

27✔

13194

               vcode_select_block(match_bb);

27✔

13195

               emit_return(emit_const(vint, i));

27✔

13197

               vcode_select_block(skip_bb);

27✔

13199

            break;

27✔

13201

         case A_OTHERS:

9✔

13202

            emit_return(emit_const(vint, i));

9✔

13203

            break;

9✔

13212

   if (!vcode_block_finished())

9✔

13215

   lower_finished(lu, NULL);

9✔

13216

   lower_unit_free(lu);

9✔

13218

   return thunk;

9✔

13221

vcode_unit_t lower_thunk(unit_registry_t *registry, tree_t t,

12,372✔

13224

   tree_t container = primary_unit_of(tree_container(t));

12,372✔

13226

   assert(parent == NULL || parent->registry == registry);

12,372✔

13228

   vcode_unit_t context = parent ? parent->vunit : NULL;

12,372✔

13229

   vcode_unit_t thunk = emit_thunk(NULL, tree_to_object(t), context);

12,372✔

13230

   lower_unit_t *lu = lower_unit_new(registry, parent, thunk, NULL, container);

12,372✔

13232

   type_t to_type = tree_type(t), from_type = to_type;

12,372✔

13234

   vcode_type_t vtype = VCODE_INVALID_TYPE;

12,372✔

13235

   switch (tree_kind(t)) {

12,372✔

13236

   case T_FCALL:

9,982✔

13237

      from_type = tree_type(tree_ref(t));

9,982✔

13238

      vtype = lower_func_result_type(type_result(from_type));

9,982✔

13239

      break;

9,982✔

13240

   case T_ATTR_REF:

68✔

13241

      vtype = lower_type(to_type);

68✔

13242

      break;

68✔

13243

   default:

2,322✔

13244

      vtype = lower_func_result_type(to_type);

2,322✔

13245

      break;

2,322✔

13248

   vcode_set_result(vtype);

12,372✔

13250

   if (parent != NULL) {

12,372✔

13251

      vcode_type_t vcontext = vtype_context(parent->name);

907✔

13252

      emit_param(vcontext, vcontext, ident_new("context"));

907✔

13255

   vcode_reg_t result_reg = lower_rvalue(lu, t);

12,372✔

13257

   if (type_is_scalar(tree_type(t)))

12,372✔

13258

      emit_return(emit_cast(vtype, vtype, result_reg));

12,103✔

13259

   else if (type_is_array(to_type))

269✔

13260

      emit_return(lower_coerce_arrays(lu, from_type, to_type, result_reg));

269✔

13264

   lower_finished(lu, NULL);

12,372✔

13265

   lower_unit_free(lu);

12,372✔

13267

   if (vcode_unit_has_undefined(thunk)) {

12,372✔

13268

      vcode_unit_unref(thunk);

1,094✔

13269

      return NULL;

1,094✔

13272

   vcode_close();

11,278✔

13273

   return thunk;

11,278✔

13276

lower_unit_t *lower_instance(unit_registry_t *ur, lower_unit_t *parent,

9,410✔

13280

   assert(tree_kind(block) == T_BLOCK);

9,410✔

13282

   vcode_select_unit(parent ? parent->vunit : NULL);

9,410✔

13284

   ident_t prefix = parent ? parent->name : lib_name(lib_work());

9,410✔

13285

   ident_t label = tree_ident(block);

9,410✔

13286

   ident_t name = ident_prefix(prefix, label, '.');

9,410✔

13288

   vcode_unit_t vu = emit_instance(name, tree_to_object(block),

9,410✔

13291

   tree_t hier = tree_decl(block, 0);

9,410✔

13292

   assert(tree_kind(hier) == T_HIER);

9,410✔

13294

   tree_t unit = tree_ref(hier), primary = NULL;

9,410✔

13295

   if (is_design_unit(unit))

9,410✔

13296

      primary = primary_unit_of(unit);

6,020✔

13300

   if (cover != NULL && tree_kind(unit) == T_COMPONENT)

9,410✔

13301

      cover = NULL;

6✔

13303

   lower_unit_t *lu = lower_unit_new(ur, parent, vu, cover, block);

9,410✔

13304

   unit_registry_put(ur, lu);

9,410✔

13306

   if (cover != NULL) {

9,410✔

13307

      if (parent == NULL)

329✔

13308

         lu->cscope = cover_create_instance(cover, NULL, block, unit);

125✔

13309

      else if (parent != NULL && parent->cover == NULL) {

204✔

13312

         assert(tree_subkind(tree_decl(parent->container, 0)) == T_COMPONENT);

6✔

13313

         lu->cscope = cover_create_instance(cover, parent->parent->cscope,

6✔

13316

      else if (tree_kind(unit) == T_ARCH)

198✔

13317

         lu->cscope = cover_create_instance(cover, parent->cscope, block, unit);

105✔

13319

         lu->cscope = cover_create_scope(cover, parent->cscope, block, NULL);

93✔

13321

      cover_ignore_from_pragmas(cover, lu->cscope, unit);

329✔

13324

   tree_global_flags_t gflags = tree_global_flags(unit);

9,410✔

13325

   if (primary != NULL)

9,410✔

13326

      gflags |= tree_global_flags(primary);

6,020✔

13328

   if (gflags & TREE_GF_INSTANCE_NAME)

9,410✔

13329

      lower_cache_instance_name(lu, ATTR_INSTANCE_NAME);

328✔

13331

   if (gflags & TREE_GF_PATH_NAME)

9,410✔

13332

      lower_cache_instance_name(lu, ATTR_PATH_NAME);

436✔

13334

   if (gflags & TREE_GF_EXTERNAL_NAME)

9,410✔

13335

      tree_visit_only(block, lower_external_name_cache, lu, T_EXTERNAL_NAME);

122✔

13337

   lower_dependencies(lu, block);

9,410✔

13338

   lower_generics(lu, block, primary);

9,410✔

13339

   lower_ports(lu, ds, block);

9,410✔

13340

   lower_decls(lu, block);

9,410✔

13342

   emit_return(VCODE_INVALID_REG);

9,410✔

13344

   lower_finished(lu, shape);

9,410✔

13345

   return lu;

9,410✔

13348

lower_unit_t *lower_unit_new(unit_registry_t *ur, lower_unit_t *parent,

44,873✔

13352

   lower_unit_t *new = xcalloc(sizeof(lower_unit_t));

44,873✔

13353

   new->parent    = parent;

44,873✔

13354

   new->objects   = hash_new(128);

44,873✔

13355

   new->container = container;

44,873✔

13356

   new->vunit     = vunit;

44,873✔

13357

   new->cover     = cover;

44,873✔

13358

   new->registry  = ur;

44,873✔

13360

   const vunit_kind_t kind = vcode_unit_kind(vunit);

44,873✔

13362

   new->name = vcode_unit_name(vunit);

44,873✔

13363

   new->mode = (kind == VCODE_UNIT_THUNK) ? LOWER_THUNK : LOWER_NORMAL;

44,873✔

13365

   return new;

44,873✔

13368

void lower_unit_free(lower_unit_t *lu)

44,873✔

13370

   assert(lu->finished);

44,873✔

13372

   hash_free(lu->objects);

44,873✔

13373

   ACLEAR(lu->free_temps);

44,873✔

13374

   free(lu);

44,873✔

13375

44,873✔

13377

vcode_unit_t get_vcode(lower_unit_t *lu)

499✔

13379

   return lu->vunit;

499✔

13382

static cover_scope_t *lower_emit_cover_scopes(lower_unit_t *lu,

4,523✔

13385

   if (lcs == NULL)

4,523✔

13386

      return lu->cscope;

1,296✔

13387

   else if (lcs->cscope != NULL)

3,227✔

13390

      cover_scope_t *parent = lower_emit_cover_scopes(lu, lcs->parent);

2,183✔

13391

      return (lcs->cscope = cover_create_scope(lu->cover, parent,

2,183✔

13396

cover_scope_t *lower_get_cover_scope(lower_unit_t *lu)

2,538✔

13398

   if (lu->cover == NULL)

2,538✔

13401

      return lower_emit_cover_scopes(lu, lu->lazy_cscope);

2,340✔

13428

unit_registry_t *unit_registry_new(void)

7,660✔

13430

   unit_registry_t *ur = xcalloc(sizeof(unit_registry_t));

7,660✔

13431

   ur->map = hash_new(128);

7,660✔

13433

   return ur;

7,660✔

13436

void unit_registry_free(unit_registry_t *ur)

7,641✔

13438

   vcode_close();

7,641✔

13440

   const void *key;

7,641✔

13441

   void *value;

7,641✔

13442

   for (hash_iter_t it = HASH_BEGIN; hash_iter(ur->map, &it, &key, &value); ) {

129,308✔

13444

      switch (pointer_tag(value)) {

121,667✔

13445

      case UNIT_FINALISED:

29,271✔

13447

            vcode_unit_t vu = untag_pointer(value, struct _vcode_unit);

29,271✔

13448

            vcode_unit_unref(vu);

29,271✔

13450

         break;

29,271✔

13452

      case UNIT_GENERATED:

3,215✔

13454

            lower_unit_t *lu = untag_pointer(value, lower_unit_t);

3,215✔

13455

            assert(lu->finished);

3,215✔

13456

            assert(lu->registry == ur);

3,215✔

13457

            vcode_unit_unref(lu->vunit);

3,215✔

13458

            lower_unit_free(lu);

3,215✔

13460

         break;

3,215✔

13462

      case UNIT_DEFERRED:

89,181✔

13464

            deferred_unit_t *du = untag_pointer(value, deferred_unit_t);

89,181✔

13465

            free(du);

89,181✔

13467

         break;

89,181✔

13474

   hash_free(ur->map);

7,641✔

13475

   free(ur);

7,641✔

13476

7,641✔

13478

void unit_registry_put(unit_registry_t *ur, lower_unit_t *lu)

19,593✔

13480

   assert(hash_get(ur->map, lu->name) == NULL);

19,593✔

13481

   hash_put(ur->map, lu->name, tag_pointer(lu, UNIT_GENERATED));

19,593✔

13482

19,593✔

13484

bool unit_registry_query(unit_registry_t *ur, ident_t ident)

62,396✔

13486

   return hash_get(ur->map, ident) != NULL;

62,396✔

13489

void unit_registry_purge(unit_registry_t *ur, ident_t prefix)

10,188✔

13491

   if (hash_get(ur->map, prefix) == NULL)

10,188✔

13492

      return;   // Fail fast if root not registered

10,188✔

13515

static void walk_dependency_cb(ident_t name, void *ctx)

53,900✔

13517

   unit_registry_t *ur = ctx;

53,900✔

13519

   if (hset_contains(ur->visited, name))

53,900✔

13522

   hset_insert(ur->visited, name);

30,590✔

13524

   void *ptr = hash_get(ur->map, name);

30,590✔

13525

   if (ptr == NULL)

30,590✔

13528

   vcode_unit_t vu = NULL;

23,921✔

13529

   switch (pointer_tag(ptr)) {

23,921✔

13530

   case UNIT_DEFERRED:

147✔

13532

         deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t);

147✔

13533

         if (arena_frozen(object_arena(du->object)))

147✔

13536

         vu = unit_registry_get(ur, name);

113✔

13538

      break;

113✔

13539

   case UNIT_FINALISED:

21,159✔

13540

      vu = untag_pointer(ptr, struct _vcode_unit);

21,159✔

13541

      break;

21,159✔

13542

   case UNIT_GENERATED:

2,615✔

13544

         lower_unit_t *lu = untag_pointer(ptr, lower_unit_t);

2,615✔

13545

         vu = lu->vunit;

2,615✔

13547

      break;

2,615✔

13552

   if (arena_frozen(object_arena(vcode_unit_object(vu))))

23,887✔

13555

   vcode_walk_dependencies(vu, walk_dependency_cb, ur);

15,453✔

13557

   for (vcode_unit_t it = vcode_unit_child(vu); it; it = vcode_unit_next(it)) {

33,917✔

13558

      assert(vcode_unit_kind(it) != VCODE_UNIT_THUNK);

18,464✔

13559

      walk_dependency_cb(vcode_unit_name(it), ctx);

18,464✔

13563

void unit_registry_flush(unit_registry_t *ur, ident_t name)

3,567✔

13565

   assert(ur->visited == NULL);

3,567✔

13566

   ur->visited = hset_new(128);

3,567✔

13570

   walk_dependency_cb(name, ur);

3,567✔

13572

   hset_free(ur->visited);

3,567✔

13573

   ur->visited = NULL;

3,567✔

13574

3,567✔

13576

void unit_registry_finalise(unit_registry_t *ur, lower_unit_t *lu)

32,492✔

13578

   assert(pointer_tag(hash_get(ur->map, lu->name)) == UNIT_GENERATED);

32,492✔

13580

   if (!lu->finished)

32,492✔

13581

      lower_finished(lu, NULL);

14,071✔

13583

   if (lu->deferred > 0)

32,492✔

13586

   hash_put(ur->map, lu->name, tag_pointer(lu->vunit, UNIT_FINALISED));

29,277✔

13588

   lower_unit_free(lu);

29,277✔

13591

vcode_unit_t unit_registry_get(unit_registry_t *ur, ident_t ident)

69,854✔

13593

   void *ptr = hash_get(ur->map, ident);

69,854✔

13594

   if (ptr == NULL) {

69,854✔

13595

      ident_t it = ident;

1,800✔

13596

      ident_t lname = ident_walk_selected(&it);

1,800✔

13597

      ident_t uname = ident_walk_selected(&it);

1,800✔

13599

      lib_t lib = lib_require(lname);

1,800✔

13601

      ident_t unit_name = ident_prefix(lname, uname, '.');

1,800✔

13602

      tree_t unit = lib_get(lib, unit_name);

1,800✔

13603

      if (unit == NULL || !is_package(unit))

1,800✔

13604

         return NULL;

166✔

13606

      if (tree_kind(unit) == T_PACKAGE && package_needs_body(unit)) {

2,813✔

13607

         tree_t body = body_of(unit);

1,182✔

13608

         if (body == NULL)

1,179✔

13611

         unit_registry_defer(ur, unit_name, NULL, emit_package,

1,178✔

13615

         unit_registry_defer(ur, unit_name, NULL, emit_package,

453✔

13618

      if (unit_name != ident) {

1,631✔

13621

         (void)unit_registry_get(ur, unit_name);

242✔

13624

      if ((ptr = hash_get(ur->map, ident)) == NULL)

1,631✔

13628

   switch (pointer_tag(ptr)) {

69,685✔

13629

   case UNIT_DEFERRED:

12,899✔

13631

         deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t);

12,899✔

13633

         vcode_state_t state;

12,899✔

13634

         vcode_state_save(&state);

12,899✔

13636

         vcode_unit_t context = du->parent ? du->parent->vunit : NULL;

12,899✔

13637

         vcode_unit_t vu = (*du->emit_fn)(ident, du->object, context);

12,899✔

13638

         tree_t container = tree_from_object(du->object);

12,899✔

13639

         lower_unit_t *lu = lower_unit_new(ur, du->parent, vu,

12,899✔

13642

         hash_put(ur->map, ident, tag_pointer(lu, UNIT_GENERATED));

12,899✔

13644

         (*du->fn)(lu, du->object);

12,899✔

13646

         for (lower_unit_t *p = du->parent; p; p = p->parent) {

25,537✔

13647

            assert(p->deferred > 0);

12,638✔

13648

            p->deferred--;

12,638✔

13651

         unit_registry_finalise(ur, lu);

12,899✔

13653

         vcode_state_restore(&state);

12,899✔

13655

         free(du);

12,899✔

13656

         return vu;

12,899✔

13659

   case UNIT_GENERATED:

10,488✔

13661

         lower_unit_t *lu = untag_pointer(ptr, lower_unit_t);

10,488✔

13662

         return lu->vunit;

10,488✔

13665

   case UNIT_FINALISED:

46,298✔

13666

      return untag_pointer(ptr, struct _vcode_unit);

46,298✔

13673

vcode_unit_t unit_registry_get_parent(unit_registry_t *ur, ident_t name)

57✔

13675

   void *ptr = hash_get(ur->map, name);

57✔

13676

   if (ptr == NULL)

57✔

13679

   switch (pointer_tag(ptr)) {

57✔

13680

   case UNIT_DEFERRED:

6✔

13682

         deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t);

6✔

13683

         return du->parent->vunit;

6✔

13685

      break;

6✔

13687

   case UNIT_FINALISED:

6✔

13689

         vcode_unit_t vu = untag_pointer(ptr, struct _vcode_unit);

6✔

13690

         return vcode_unit_context(vu);

6✔

13693

   case UNIT_GENERATED:

45✔

13695

         lower_unit_t *lu = untag_pointer(ptr, lower_unit_t);

45✔

13696

         return lu->parent->vunit;

45✔

13705

void unit_registry_defer(unit_registry_t *ur, ident_t ident,

102,180✔

13710

   void *ptr = hash_get(ur->map, ident);

102,180✔

13711

   if (ptr == NULL) {

102,180✔

13712

      deferred_unit_t *du = xcalloc(sizeof(deferred_unit_t));

102,080✔

13713

      du->emit_fn = emit_fn;

102,080✔

13714

      du->fn      = fn;

102,080✔

13715

      du->parent  = parent;

102,080✔

13716

      du->cover   = cover;

102,080✔

13717

      du->object  = object;

102,080✔

13719

      for (lower_unit_t *p = du->parent; p; p = p->parent)

206,208✔

13720

         p->deferred++;

104,128✔

13722

      hash_put(ur->map, ident, tag_pointer(du, UNIT_DEFERRED));

102,080✔

13725

   else if (pointer_tag(ptr) == UNIT_DEFERRED) {

100✔

13726

      deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t);

99✔

13727

      assert(du->emit_fn == emit_fn);

99✔

13728

      assert(du->fn == fn);

99✔

13729

      assert(du->cover == cover);

99✔

13730

      assert(du->object == object);

99✔

13733

102,180✔

nickg / nvc / 13887457702

Source File
Press 'n' to go to next uncovered line, 'b' for previous

nickg / nvc / 13887457702

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous