verilog/alu/v6/obj_dir/Valu6___024root__DepSet_he7565067__0.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// Verilated -*- C++ -*-
// DESCRIPTION: Verilator output: Design implementation internals
// See Valu6.h for the primary calling header

#include "verilated.h"

#include "Valu6___024root.h"

VL_INLINE_OPT void Valu6___024root___combo__TOP__0(Valu6___024root* vlSelf) {
    if (false && vlSelf) {}  // Prevent unused
    Valu6__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    VL_DEBUG_IF(VL_DBG_MSGF("+    Valu6___024root___combo__TOP__0\n"); );
    // Body
    vlSelf->alu6__DOT__sum = (vlSelf->alu_in_1 + ((IData)(
                                                          (((IData)(vlSelf->alu_op_i) 
                                                            >> 3U) 
                                                           | (2U 
                                                              == 
                                                              (3U 
                                                               & (IData)(vlSelf->alu_op_i)))))
                                                   ? 
                                                  ((IData)(1U) 
                                                   + 
                                                   (~ vlSelf->alu_in_2))
                                                   : vlSelf->alu_in_2));
    vlSelf->alu_output = ((0U == (7U & (IData)(vlSelf->alu_op_i)))
                           ? vlSelf->alu6__DOT__sum
                           : ((4U == (7U & (IData)(vlSelf->alu_op_i)))
                               ? (vlSelf->alu_in_1 
                                  ^ vlSelf->alu_in_2)
                               : ((6U == (7U & (IData)(vlSelf->alu_op_i)))
                                   ? (vlSelf->alu_in_1 
                                      | vlSelf->alu_in_2)
                                   : ((7U == (7U & (IData)(vlSelf->alu_op_i)))
                                       ? (vlSelf->alu_in_1 
                                          & vlSelf->alu_in_2)
                                       : ((1U == (7U 
                                                  & (IData)(vlSelf->alu_op_i)))
                                           ? ((0x40U 
                                               & vlSelf->alu_in_2)
                                               ? 0U
                                               : ((0x1fU 
                                                   >= 
                                                   (0x3fU 
                                                    & vlSelf->alu_in_2))
                                                   ? 
                                                  (vlSelf->alu_in_1 
                                                   << 
                                                   (0x3fU 
                                                    & vlSelf->alu_in_2))
                                                   : 0U))
                                           : ((5U == 
                                               (7U 
                                                & (IData)(vlSelf->alu_op_i)))
                                               ? ((
                                                   (0x1fU 
                                                    >= 
                                                    (0x3fU 
                                                     & vlSelf->alu_in_2))
                                                    ? 
                                                   (vlSelf->alu_in_1 
                                                    >> 
                                                    (0x3fU 
                                                     & vlSelf->alu_in_2))
                                                    : 0U) 
                                                  | ((8U 
                                                      & (IData)(vlSelf->alu_op_i))
                                                      ? 
                                                     ((IData)(0xffffffffU) 
                                                      << 
                                                      ((vlSelf->alu_in_2 
                                                        >> 0x1fU)
                                                        ? 0U
                                                        : 
                                                       ((0x10U 
                                                         & ((~ 
                                                             (vlSelf->alu_in_2 
                                                              >> 4U)) 
                                                            << 4U)) 
                                                        | ((8U 
                                                            & ((~ 
                                                                (vlSelf->alu_in_2 
                                                                 >> 3U)) 
                                                               << 3U)) 
                                                           | ((4U 
                                                               & ((~ 
                                                                   (vlSelf->alu_in_2 
                                                                    >> 2U)) 
                                                                  << 2U)) 
                                                              | ((2U 
                                                                  & ((~ 
                                                                      (vlSelf->alu_in_2 
                                                                       >> 1U)) 
                                                                     << 1U)) 
                                                                 | (1U 
                                                                    & (~ vlSelf->alu_in_2))))))))
                                                      : 0U))
                                               : ((2U 
                                                   == 
                                                   (7U 
                                                    & (IData)(vlSelf->alu_op_i)))
                                                   ? 
                                                  (vlSelf->alu6__DOT__sum 
                                                   >> 0x1fU)
                                                   : 
                                                  ((3U 
                                                    == 
                                                    (7U 
                                                     & (IData)(vlSelf->alu_op_i)))
                                                    ? 
                                                   ((vlSelf->alu_in_1 
                                                     < vlSelf->alu_in_2)
                                                     ? 1U
                                                     : 0U)
                                                    : 0U))))))));
}

void Valu6___024root___eval(Valu6___024root* vlSelf) {
    if (false && vlSelf) {}  // Prevent unused
    Valu6__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    VL_DEBUG_IF(VL_DBG_MSGF("+    Valu6___024root___eval\n"); );
    // Body
    Valu6___024root___combo__TOP__0(vlSelf);
}

#ifdef VL_DEBUG
void Valu6___024root___eval_debug_assertions(Valu6___024root* vlSelf) {
    if (false && vlSelf) {}  // Prevent unused
    Valu6__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    VL_DEBUG_IF(VL_DBG_MSGF("+    Valu6___024root___eval_debug_assertions\n"); );
    // Body
    if (VL_UNLIKELY((vlSelf->alu_op_i & 0xf0U))) {
        Verilated::overWidthError("alu_op_i");}
}
#endif  // VL_DEBUG