Revision a699a7be target-cris/translate.c

b/target-cris/translate.c
1361 1361

  
1362 1362
/* Start of insn decoders.  */
1363 1363

  
1364
static unsigned int dec_bccq(DisasContext *dc)
1364
static int dec_bccq(DisasContext *dc)
1365 1365
{
1366 1366
	int32_t offset;
1367 1367
	int sign;
......
1381 1381
	cris_prepare_cc_branch (dc, offset, cond);
1382 1382
	return 2;
1383 1383
}
1384
static unsigned int dec_addoq(DisasContext *dc)
1384
static int dec_addoq(DisasContext *dc)
1385 1385
{
1386 1386
	int32_t imm;
1387 1387

  
......
1395 1395

  
1396 1396
	return 2;
1397 1397
}
1398
static unsigned int dec_addq(DisasContext *dc)
1398
static int dec_addq(DisasContext *dc)
1399 1399
{
1400 1400
	LOG_DIS("addq %u, $r%u\n", dc->op1, dc->op2);
1401 1401

  
......
1407 1407
		    cpu_R[dc->op2], cpu_R[dc->op2], tcg_const_tl(dc->op1), 4);
1408 1408
	return 2;
1409 1409
}
1410
static unsigned int dec_moveq(DisasContext *dc)
1410
static int dec_moveq(DisasContext *dc)
1411 1411
{
1412 1412
	uint32_t imm;
1413 1413

  
......
1418 1418
	tcg_gen_movi_tl(cpu_R[dc->op2], imm);
1419 1419
	return 2;
1420 1420
}
1421
static unsigned int dec_subq(DisasContext *dc)
1421
static int dec_subq(DisasContext *dc)
1422 1422
{
1423 1423
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
1424 1424

  
......
1429 1429
		    cpu_R[dc->op2], cpu_R[dc->op2], tcg_const_tl(dc->op1), 4);
1430 1430
	return 2;
1431 1431
}
1432
static unsigned int dec_cmpq(DisasContext *dc)
1432
static int dec_cmpq(DisasContext *dc)
1433 1433
{
1434 1434
	uint32_t imm;
1435 1435
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
......
1442 1442
		    cpu_R[dc->op2], cpu_R[dc->op2], tcg_const_tl(imm), 4);
1443 1443
	return 2;
1444 1444
}
1445
static unsigned int dec_andq(DisasContext *dc)
1445
static int dec_andq(DisasContext *dc)
1446 1446
{
1447 1447
	uint32_t imm;
1448 1448
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
......
1455 1455
		    cpu_R[dc->op2], cpu_R[dc->op2], tcg_const_tl(imm), 4);
1456 1456
	return 2;
1457 1457
}
1458
static unsigned int dec_orq(DisasContext *dc)
1458
static int dec_orq(DisasContext *dc)
1459 1459
{
1460 1460
	uint32_t imm;
1461 1461
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
......
1467 1467
		    cpu_R[dc->op2], cpu_R[dc->op2], tcg_const_tl(imm), 4);
1468 1468
	return 2;
1469 1469
}
1470
static unsigned int dec_btstq(DisasContext *dc)
1470
static int dec_btstq(DisasContext *dc)
1471 1471
{
1472 1472
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1473 1473
	LOG_DIS("btstq %u, $r%d\n", dc->op1, dc->op2);
......
1482 1482
	dc->flags_uptodate = 1;
1483 1483
	return 2;
1484 1484
}
1485
static unsigned int dec_asrq(DisasContext *dc)
1485
static int dec_asrq(DisasContext *dc)
1486 1486
{
1487 1487
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1488 1488
	LOG_DIS("asrq %u, $r%d\n", dc->op1, dc->op2);
......
1494 1494
		    cpu_R[dc->op2], cpu_R[dc->op2], 4);
1495 1495
	return 2;
1496 1496
}
1497
static unsigned int dec_lslq(DisasContext *dc)
1497
static int dec_lslq(DisasContext *dc)
1498 1498
{
1499 1499
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1500 1500
	LOG_DIS("lslq %u, $r%d\n", dc->op1, dc->op2);
......
1508 1508
		    cpu_R[dc->op2], cpu_R[dc->op2], 4);
1509 1509
	return 2;
1510 1510
}
1511
static unsigned int dec_lsrq(DisasContext *dc)
1511
static int dec_lsrq(DisasContext *dc)
1512 1512
{
1513 1513
	dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1514 1514
	LOG_DIS("lsrq %u, $r%d\n", dc->op1, dc->op2);
......
1522 1522
	return 2;
1523 1523
}
1524 1524

  
1525
static unsigned int dec_move_r(DisasContext *dc)
1525
static int dec_move_r(DisasContext *dc)
1526 1526
{
1527 1527
	int size = memsize_zz(dc);
1528 1528

  
......
1550 1550
	return 2;
1551 1551
}
1552 1552

  
1553
static unsigned int dec_scc_r(DisasContext *dc)
1553
static int dec_scc_r(DisasContext *dc)
1554 1554
{
1555 1555
	int cond = dc->op2;
1556 1556

  
......
1593 1593
	}
1594 1594
}
1595 1595

  
1596
static unsigned int dec_and_r(DisasContext *dc)
1596
static int dec_and_r(DisasContext *dc)
1597 1597
{
1598 1598
	TCGv t[2];
1599 1599
	int size = memsize_zz(dc);
......
1610 1610
	return 2;
1611 1611
}
1612 1612

  
1613
static unsigned int dec_lz_r(DisasContext *dc)
1613
static int dec_lz_r(DisasContext *dc)
1614 1614
{
1615 1615
	TCGv t0;
1616 1616
	LOG_DIS("lz $r%u, $r%u\n",
......
1623 1623
	return 2;
1624 1624
}
1625 1625

  
1626
static unsigned int dec_lsl_r(DisasContext *dc)
1626
static int dec_lsl_r(DisasContext *dc)
1627 1627
{
1628 1628
	TCGv t[2];
1629 1629
	int size = memsize_zz(dc);
......
1640 1640
	return 2;
1641 1641
}
1642 1642

  
1643
static unsigned int dec_lsr_r(DisasContext *dc)
1643
static int dec_lsr_r(DisasContext *dc)
1644 1644
{
1645 1645
	TCGv t[2];
1646 1646
	int size = memsize_zz(dc);
......
1657 1657
	return 2;
1658 1658
}
1659 1659

  
1660
static unsigned int dec_asr_r(DisasContext *dc)
1660
static int dec_asr_r(DisasContext *dc)
1661 1661
{
1662 1662
	TCGv t[2];
1663 1663
	int size = memsize_zz(dc);
......
1674 1674
	return 2;
1675 1675
}
1676 1676

  
1677
static unsigned int dec_muls_r(DisasContext *dc)
1677
static int dec_muls_r(DisasContext *dc)
1678 1678
{
1679 1679
	TCGv t[2];
1680 1680
	int size = memsize_zz(dc);
......
1690 1690
	return 2;
1691 1691
}
1692 1692

  
1693
static unsigned int dec_mulu_r(DisasContext *dc)
1693
static int dec_mulu_r(DisasContext *dc)
1694 1694
{
1695 1695
	TCGv t[2];
1696 1696
	int size = memsize_zz(dc);
......
1707 1707
}
1708 1708

  
1709 1709

  
1710
static unsigned int dec_dstep_r(DisasContext *dc)
1710
static int dec_dstep_r(DisasContext *dc)
1711 1711
{
1712 1712
	LOG_DIS("dstep $r%u, $r%u\n", dc->op1, dc->op2);
1713 1713
	cris_cc_mask(dc, CC_MASK_NZ);
......
1716 1716
	return 2;
1717 1717
}
1718 1718

  
1719
static unsigned int dec_xor_r(DisasContext *dc)
1719
static int dec_xor_r(DisasContext *dc)
1720 1720
{
1721 1721
	TCGv t[2];
1722 1722
	int size = memsize_zz(dc);
......
1732 1732
	return 2;
1733 1733
}
1734 1734

  
1735
static unsigned int dec_bound_r(DisasContext *dc)
1735
static int dec_bound_r(DisasContext *dc)
1736 1736
{
1737 1737
	TCGv l0;
1738 1738
	int size = memsize_zz(dc);
......
1746 1746
	return 2;
1747 1747
}
1748 1748

  
1749
static unsigned int dec_cmp_r(DisasContext *dc)
1749
static int dec_cmp_r(DisasContext *dc)
1750 1750
{
1751 1751
	TCGv t[2];
1752 1752
	int size = memsize_zz(dc);
......
1761 1761
	return 2;
1762 1762
}
1763 1763

  
1764
static unsigned int dec_abs_r(DisasContext *dc)
1764
static int dec_abs_r(DisasContext *dc)
1765 1765
{
1766 1766
	TCGv t0;
1767 1767

  
......
1780 1780
	return 2;
1781 1781
}
1782 1782

  
1783
static unsigned int dec_add_r(DisasContext *dc)
1783
static int dec_add_r(DisasContext *dc)
1784 1784
{
1785 1785
	TCGv t[2];
1786 1786
	int size = memsize_zz(dc);
......
1795 1795
	return 2;
1796 1796
}
1797 1797

  
1798
static unsigned int dec_addc_r(DisasContext *dc)
1798
static int dec_addc_r(DisasContext *dc)
1799 1799
{
1800 1800
	LOG_DIS("addc $r%u, $r%u\n",
1801 1801
		    dc->op1, dc->op2);
......
1810 1810
	return 2;
1811 1811
}
1812 1812

  
1813
static unsigned int dec_mcp_r(DisasContext *dc)
1813
static int dec_mcp_r(DisasContext *dc)
1814 1814
{
1815 1815
	LOG_DIS("mcp $p%u, $r%u\n",
1816 1816
		     dc->op2, dc->op1);
......
1837 1837
}
1838 1838
#endif
1839 1839

  
1840
static unsigned int dec_swap_r(DisasContext *dc)
1840
static int dec_swap_r(DisasContext *dc)
1841 1841
{
1842 1842
	TCGv t0;
1843 1843
#if DISAS_CRIS
......
1863 1863
	return 2;
1864 1864
}
1865 1865

  
1866
static unsigned int dec_or_r(DisasContext *dc)
1866
static int dec_or_r(DisasContext *dc)
1867 1867
{
1868 1868
	TCGv t[2];
1869 1869
	int size = memsize_zz(dc);
......
1877 1877
	return 2;
1878 1878
}
1879 1879

  
1880
static unsigned int dec_addi_r(DisasContext *dc)
1880
static int dec_addi_r(DisasContext *dc)
1881 1881
{
1882 1882
	TCGv t0;
1883 1883
	LOG_DIS("addi.%c $r%u, $r%u\n",
......
1890 1890
	return 2;
1891 1891
}
1892 1892

  
1893
static unsigned int dec_addi_acr(DisasContext *dc)
1893
static int dec_addi_acr(DisasContext *dc)
1894 1894
{
1895 1895
	TCGv t0;
1896 1896
	LOG_DIS("addi.%c $r%u, $r%u, $acr\n",
......
1903 1903
	return 2;
1904 1904
}
1905 1905

  
1906
static unsigned int dec_neg_r(DisasContext *dc)
1906
static int dec_neg_r(DisasContext *dc)
1907 1907
{
1908 1908
	TCGv t[2];
1909 1909
	int size = memsize_zz(dc);
......
1918 1918
	return 2;
1919 1919
}
1920 1920

  
1921
static unsigned int dec_btst_r(DisasContext *dc)
1921
static int dec_btst_r(DisasContext *dc)
1922 1922
{
1923 1923
	LOG_DIS("btst $r%u, $r%u\n",
1924 1924
		    dc->op1, dc->op2);
......
1933 1933
	return 2;
1934 1934
}
1935 1935

  
1936
static unsigned int dec_sub_r(DisasContext *dc)
1936
static int dec_sub_r(DisasContext *dc)
1937 1937
{
1938 1938
	TCGv t[2];
1939 1939
	int size = memsize_zz(dc);
......
1948 1948
}
1949 1949

  
1950 1950
/* Zero extension. From size to dword.  */
1951
static unsigned int dec_movu_r(DisasContext *dc)
1951
static int dec_movu_r(DisasContext *dc)
1952 1952
{
1953 1953
	TCGv t0;
1954 1954
	int size = memsize_z(dc);
......
1965 1965
}
1966 1966

  
1967 1967
/* Sign extension. From size to dword.  */
1968
static unsigned int dec_movs_r(DisasContext *dc)
1968
static int dec_movs_r(DisasContext *dc)
1969 1969
{
1970 1970
	TCGv t0;
1971 1971
	int size = memsize_z(dc);
......
1984 1984
}
1985 1985

  
1986 1986
/* zero extension. From size to dword.  */
1987
static unsigned int dec_addu_r(DisasContext *dc)
1987
static int dec_addu_r(DisasContext *dc)
1988 1988
{
1989 1989
	TCGv t0;
1990 1990
	int size = memsize_z(dc);
......
2003 2003
}
2004 2004

  
2005 2005
/* Sign extension. From size to dword.  */
2006
static unsigned int dec_adds_r(DisasContext *dc)
2006
static int dec_adds_r(DisasContext *dc)
2007 2007
{
2008 2008
	TCGv t0;
2009 2009
	int size = memsize_z(dc);
......
2022 2022
}
2023 2023

  
2024 2024
/* Zero extension. From size to dword.  */
2025
static unsigned int dec_subu_r(DisasContext *dc)
2025
static int dec_subu_r(DisasContext *dc)
2026 2026
{
2027 2027
	TCGv t0;
2028 2028
	int size = memsize_z(dc);
......
2041 2041
}
2042 2042

  
2043 2043
/* Sign extension. From size to dword.  */
2044
static unsigned int dec_subs_r(DisasContext *dc)
2044
static int dec_subs_r(DisasContext *dc)
2045 2045
{
2046 2046
	TCGv t0;
2047 2047
	int size = memsize_z(dc);
......
2059 2059
	return 2;
2060 2060
}
2061 2061

  
2062
static unsigned int dec_setclrf(DisasContext *dc)
2062
static int dec_setclrf(DisasContext *dc)
2063 2063
{
2064 2064
	uint32_t flags;
2065 2065
	int set = (~dc->opcode >> 2) & 1;
......
2130 2130
	return 2;
2131 2131
}
2132 2132

  
2133
static unsigned int dec_move_rs(DisasContext *dc)
2133
static int dec_move_rs(DisasContext *dc)
2134 2134
{
2135 2135
	LOG_DIS("move $r%u, $s%u\n", dc->op1, dc->op2);
2136 2136
	cris_cc_mask(dc, 0);
2137 2137
	gen_helper_movl_sreg_reg(tcg_const_tl(dc->op2), tcg_const_tl(dc->op1));
2138 2138
	return 2;
2139 2139
}
2140
static unsigned int dec_move_sr(DisasContext *dc)
2140
static int dec_move_sr(DisasContext *dc)
2141 2141
{
2142 2142
	LOG_DIS("move $s%u, $r%u\n", dc->op2, dc->op1);
2143 2143
	cris_cc_mask(dc, 0);
......
2145 2145
	return 2;
2146 2146
}
2147 2147

  
2148
static unsigned int dec_move_rp(DisasContext *dc)
2148
static int dec_move_rp(DisasContext *dc)
2149 2149
{
2150 2150
	TCGv t[2];
2151 2151
	LOG_DIS("move $r%u, $p%u\n", dc->op1, dc->op2);
......
2175 2175
	tcg_temp_free(t[0]);
2176 2176
	return 2;
2177 2177
}
2178
static unsigned int dec_move_pr(DisasContext *dc)
2178
static int dec_move_pr(DisasContext *dc)
2179 2179
{
2180 2180
	TCGv t0;
2181 2181
	LOG_DIS("move $p%u, $r%u\n", dc->op2, dc->op1);
......
2197 2197
	return 2;
2198 2198
}
2199 2199

  
2200
static unsigned int dec_move_mr(DisasContext *dc)
2200
static int dec_move_mr(DisasContext *dc)
2201 2201
{
2202 2202
	int memsize = memsize_zz(dc);
2203 2203
	int insn_len;
......
2239 2239
	tcg_temp_free(t[1]);
2240 2240
}
2241 2241

  
2242
static unsigned int dec_movs_m(DisasContext *dc)
2242
static int dec_movs_m(DisasContext *dc)
2243 2243
{
2244 2244
	TCGv t[2];
2245 2245
	int memsize = memsize_z(dc);
......
2260 2260
	return insn_len;
2261 2261
}
2262 2262

  
2263
static unsigned int dec_addu_m(DisasContext *dc)
2263
static int dec_addu_m(DisasContext *dc)
2264 2264
{
2265 2265
	TCGv t[2];
2266 2266
	int memsize = memsize_z(dc);
......
2281 2281
	return insn_len;
2282 2282
}
2283 2283

  
2284
static unsigned int dec_adds_m(DisasContext *dc)
2284
static int dec_adds_m(DisasContext *dc)
2285 2285
{
2286 2286
	TCGv t[2];
2287 2287
	int memsize = memsize_z(dc);
......
2301 2301
	return insn_len;
2302 2302
}
2303 2303

  
2304
static unsigned int dec_subu_m(DisasContext *dc)
2304
static int dec_subu_m(DisasContext *dc)
2305 2305
{
2306 2306
	TCGv t[2];
2307 2307
	int memsize = memsize_z(dc);
......
2321 2321
	return insn_len;
2322 2322
}
2323 2323

  
2324
static unsigned int dec_subs_m(DisasContext *dc)
2324
static int dec_subs_m(DisasContext *dc)
2325 2325
{
2326 2326
	TCGv t[2];
2327 2327
	int memsize = memsize_z(dc);
......
2341 2341
	return insn_len;
2342 2342
}
2343 2343

  
2344
static unsigned int dec_movu_m(DisasContext *dc)
2344
static int dec_movu_m(DisasContext *dc)
2345 2345
{
2346 2346
	TCGv t[2];
2347 2347
	int memsize = memsize_z(dc);
......
2361 2361
	return insn_len;
2362 2362
}
2363 2363

  
2364
static unsigned int dec_cmpu_m(DisasContext *dc)
2364
static int dec_cmpu_m(DisasContext *dc)
2365 2365
{
2366 2366
	TCGv t[2];
2367 2367
	int memsize = memsize_z(dc);
......
2380 2380
	return insn_len;
2381 2381
}
2382 2382

  
2383
static unsigned int dec_cmps_m(DisasContext *dc)
2383
static int dec_cmps_m(DisasContext *dc)
2384 2384
{
2385 2385
	TCGv t[2];
2386 2386
	int memsize = memsize_z(dc);
......
2401 2401
	return insn_len;
2402 2402
}
2403 2403

  
2404
static unsigned int dec_cmp_m(DisasContext *dc)
2404
static int dec_cmp_m(DisasContext *dc)
2405 2405
{
2406 2406
	TCGv t[2];
2407 2407
	int memsize = memsize_zz(dc);
......
2422 2422
	return insn_len;
2423 2423
}
2424 2424

  
2425
static unsigned int dec_test_m(DisasContext *dc)
2425
static int dec_test_m(DisasContext *dc)
2426 2426
{
2427 2427
	TCGv t[2];
2428 2428
	int memsize = memsize_zz(dc);
......
2446 2446
	return insn_len;
2447 2447
}
2448 2448

  
2449
static unsigned int dec_and_m(DisasContext *dc)
2449
static int dec_and_m(DisasContext *dc)
2450 2450
{
2451 2451
	TCGv t[2];
2452 2452
	int memsize = memsize_zz(dc);
......
2465 2465
	return insn_len;
2466 2466
}
2467 2467

  
2468
static unsigned int dec_add_m(DisasContext *dc)
2468
static int dec_add_m(DisasContext *dc)
2469 2469
{
2470 2470
	TCGv t[2];
2471 2471
	int memsize = memsize_zz(dc);
......
2485 2485
	return insn_len;
2486 2486
}
2487 2487

  
2488
static unsigned int dec_addo_m(DisasContext *dc)
2488
static int dec_addo_m(DisasContext *dc)
2489 2489
{
2490 2490
	TCGv t[2];
2491 2491
	int memsize = memsize_zz(dc);
......
2504 2504
	return insn_len;
2505 2505
}
2506 2506

  
2507
static unsigned int dec_bound_m(DisasContext *dc)
2507
static int dec_bound_m(DisasContext *dc)
2508 2508
{
2509 2509
	TCGv l[2];
2510 2510
	int memsize = memsize_zz(dc);
......
2525 2525
	return insn_len;
2526 2526
}
2527 2527

  
2528
static unsigned int dec_addc_mr(DisasContext *dc)
2528
static int dec_addc_mr(DisasContext *dc)
2529 2529
{
2530 2530
	TCGv t[2];
2531 2531
	int insn_len = 2;
......
2548 2548
	return insn_len;
2549 2549
}
2550 2550

  
2551
static unsigned int dec_sub_m(DisasContext *dc)
2551
static int dec_sub_m(DisasContext *dc)
2552 2552
{
2553 2553
	TCGv t[2];
2554 2554
	int memsize = memsize_zz(dc);
......
2567 2567
	return insn_len;
2568 2568
}
2569 2569

  
2570
static unsigned int dec_or_m(DisasContext *dc)
2570
static int dec_or_m(DisasContext *dc)
2571 2571
{
2572 2572
	TCGv t[2];
2573 2573
	int memsize = memsize_zz(dc);
......
2587 2587
	return insn_len;
2588 2588
}
2589 2589

  
2590
static unsigned int dec_move_mp(DisasContext *dc)
2590
static int dec_move_mp(DisasContext *dc)
2591 2591
{
2592 2592
	TCGv t[2];
2593 2593
	int memsize = memsize_zz(dc);
......
2619 2619
	return insn_len;
2620 2620
}
2621 2621

  
2622
static unsigned int dec_move_pm(DisasContext *dc)
2622
static int dec_move_pm(DisasContext *dc)
2623 2623
{
2624 2624
	TCGv t0;
2625 2625
	int memsize;
......
2645 2645
	return 2;
2646 2646
}
2647 2647

  
2648
static unsigned int dec_movem_mr(DisasContext *dc)
2648
static int dec_movem_mr(DisasContext *dc)
2649 2649
{
2650 2650
	TCGv_i64 tmp[16];
2651 2651
        TCGv tmp32;
......
2692 2692
	return 2;
2693 2693
}
2694 2694

  
2695
static unsigned int dec_movem_rm(DisasContext *dc)
2695
static int dec_movem_rm(DisasContext *dc)
2696 2696
{
2697 2697
	TCGv tmp;
2698 2698
	TCGv addr;
......
2721 2721
	return 2;
2722 2722
}
2723 2723

  
2724
static unsigned int dec_move_rm(DisasContext *dc)
2724
static int dec_move_rm(DisasContext *dc)
2725 2725
{
2726 2726
	int memsize;
2727 2727

  
......
2740 2740
	return 2;
2741 2741
}
2742 2742

  
2743
static unsigned int dec_lapcq(DisasContext *dc)
2743
static int dec_lapcq(DisasContext *dc)
2744 2744
{
2745 2745
	LOG_DIS("lapcq %x, $r%u\n",
2746 2746
		    dc->pc + dc->op1*2, dc->op2);
......
2749 2749
	return 2;
2750 2750
}
2751 2751

  
2752
static unsigned int dec_lapc_im(DisasContext *dc)
2752
static int dec_lapc_im(DisasContext *dc)
2753 2753
{
2754 2754
	unsigned int rd;
2755 2755
	int32_t imm;
......
2768 2768
}
2769 2769

  
2770 2770
/* Jump to special reg.  */
2771
static unsigned int dec_jump_p(DisasContext *dc)
2771
static int dec_jump_p(DisasContext *dc)
2772 2772
{
2773 2773
	LOG_DIS("jump $p%u\n", dc->op2);
2774 2774

  
......
2783 2783
}
2784 2784

  
2785 2785
/* Jump and save.  */
2786
static unsigned int dec_jas_r(DisasContext *dc)
2786
static int dec_jas_r(DisasContext *dc)
2787 2787
{
2788 2788
	LOG_DIS("jas $r%u, $p%u\n", dc->op1, dc->op2);
2789 2789
	cris_cc_mask(dc, 0);
......
2797 2797
	return 2;
2798 2798
}
2799 2799

  
2800
static unsigned int dec_jas_im(DisasContext *dc)
2800
static int dec_jas_im(DisasContext *dc)
2801 2801
{
2802 2802
	uint32_t imm;
2803 2803

  
......
2813 2813
	return 6;
2814 2814
}
2815 2815

  
2816
static unsigned int dec_jasc_im(DisasContext *dc)
2816
static int dec_jasc_im(DisasContext *dc)
2817 2817
{
2818 2818
	uint32_t imm;
2819 2819

  
......
2829 2829
	return 6;
2830 2830
}
2831 2831

  
2832
static unsigned int dec_jasc_r(DisasContext *dc)
2832
static int dec_jasc_r(DisasContext *dc)
2833 2833
{
2834 2834
	LOG_DIS("jasc_r $r%u, $p%u\n", dc->op1, dc->op2);
2835 2835
	cris_cc_mask(dc, 0);
......
2840 2840
	return 2;
2841 2841
}
2842 2842

  
2843
static unsigned int dec_bcc_im(DisasContext *dc)
2843
static int dec_bcc_im(DisasContext *dc)
2844 2844
{
2845 2845
	int32_t offset;
2846 2846
	uint32_t cond = dc->op2;
......
2857 2857
	return 4;
2858 2858
}
2859 2859

  
2860
static unsigned int dec_bas_im(DisasContext *dc)
2860
static int dec_bas_im(DisasContext *dc)
2861 2861
{
2862 2862
	int32_t simm;
2863 2863

  
......
2874 2874
	return 6;
2875 2875
}
2876 2876

  
2877
static unsigned int dec_basc_im(DisasContext *dc)
2877
static int dec_basc_im(DisasContext *dc)
2878 2878
{
2879 2879
	int32_t simm;
2880 2880
	simm = ldl_code(dc->pc + 2);
......
2889 2889
	return 6;
2890 2890
}
2891 2891

  
2892
static unsigned int dec_rfe_etc(DisasContext *dc)
2892
static int dec_rfe_etc(DisasContext *dc)
2893 2893
{
2894 2894
	cris_cc_mask(dc, 0);
2895 2895

  
......
2936 2936
	return 2;
2937 2937
}
2938 2938

  
2939
static unsigned int dec_ftag_fidx_d_m(DisasContext *dc)
2939
static int dec_ftag_fidx_d_m(DisasContext *dc)
2940 2940
{
2941 2941
	return 2;
2942 2942
}
2943 2943

  
2944
static unsigned int dec_ftag_fidx_i_m(DisasContext *dc)
2944
static int dec_ftag_fidx_i_m(DisasContext *dc)
2945 2945
{
2946 2946
	return 2;
2947 2947
}
2948 2948

  
2949
static unsigned int dec_null(DisasContext *dc)
2949
static int dec_null(DisasContext *dc)
2950 2950
{
2951 2951
	printf ("unknown insn pc=%x opc=%x op1=%x op2=%x\n",
2952 2952
		dc->pc, dc->opcode, dc->op1, dc->op2);
......
2960 2960
		uint32_t bits;
2961 2961
		uint32_t mask;
2962 2962
	};
2963
	unsigned int (*dec)(DisasContext *dc);
2963
	int (*dec)(DisasContext *dc);
2964 2964
} decinfo[] = {
2965 2965
	/* Order matters here.  */
2966 2966
	{DEC_MOVEQ, dec_moveq},
......
3068 3068

  
3069 3069
static unsigned int crisv32_decoder(DisasContext *dc)
3070 3070
{
3071
	unsigned int insn_len = 2;
3071
	int insn_len = 2;
3072 3072
	int i;
3073 3073

  
3074 3074
	if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP)))

Also available in: Unified diff