aboutsummaryrefslogtreecommitdiffstats
path: root/techlibs/ecp5/cells_map.v
blob: c031703a92fd366265d8e5d1c13825abf309f975 (plain)
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
module  \$_DFF_N_ (input D, C, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(1'b0), .DI(D), .Q(Q)); endmodule
module  \$_DFF_P_ (input D, C, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(1'b0), .DI(D), .Q(Q)); endmodule

module  \$_DFFE_NN_ (input D, C, E, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("INV"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(1'b0), .DI(D), .Q(Q)); endmodule
module  \$_DFFE_PN_ (input D, C, E, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("INV"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(1'b0), .DI(D), .Q(Q)); endmodule

module  \$_DFFE_NP_ (input D, C, E, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(1'b0), .DI(D), .Q(Q)); endmodule
module  \$_DFFE_PP_ (input D, C, E, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(1'b0), .DI(D), .Q(Q)); endmodule

module  \$_DFF_NN0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$_DFF_NN1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$_DFF_PN0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$_DFF_PN1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule

module  \$_DFF_NP0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$_DFF_NP1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$_DFF_PP0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$_DFF_PP1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule

module  \$__DFFS_NN0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFS_NN1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFS_PN0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFS_PN1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!R), .DI(D), .Q(Q)); endmodule

module  \$__DFFS_NP0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFS_NP1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFS_PP0_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFS_PP1_ (input D, C, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(R), .DI(D), .Q(Q)); endmodule

module  \$__DFFE_NN0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFE_NN1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFE_PN0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFE_PN1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule

module  \$__DFFE_NP0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFE_NP1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFE_PP0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFE_PP1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule

module  \$__DFFSE_NN0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFSE_NN1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFSE_PN0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule
module  \$__DFFSE_PN1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(!R), .DI(D), .Q(Q)); endmodule

module  \$__DFFSE_NP0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFSE_NP1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("INV"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFSE_PP0 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule
module  \$__DFFSE_PP1 (input D, C, E, R, output Q); TRELLIS_FF #(.GSR("AUTO"), .CEMUX("CE"), .CLKMUX("CLK"), .LSRMUX("LSR"), .REGSET("SET"), .SRMODE("LSR_OVER_CE"))  _TECHMAP_REPLACE_ (.CLK(C), .CE(E), .LSR(R), .DI(D), .Q(Q)); endmodule

`ifdef ASYNC_PRLD
module  \$_DLATCH_N_ (input E, input D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.LSR(!E), .DI(1'b0), .M(D), .Q(Q)); endmodule
module  \$_DLATCH_P_ (input E, input D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.LSR(E), .DI(1'b0), .M(D), .Q(Q)); endmodule

module \$_DFFSR_NNN_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("INV"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!S || !R), .DI(D), .M(R), .Q(Q)); endmodule
module \$_DFFSR_NNP_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("INV"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!S || R), .DI(D), .M(!R), .Q(Q)); endmodule
module \$_DFFSR_NPN_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("INV"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(S || !R), .DI(D), .M(R), .Q(Q)); endmodule
module \$_DFFSR_NPP_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("INV"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(S || R), .DI(D), .M(!R), .Q(Q)); endmodule

module \$_DFFSR_PNN_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!S || !R), .DI(D), .M(R), .Q(Q)); endmodule
module \$_DFFSR_PNP_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(!S || R), .DI(D), .M(!R), .Q(Q)); endmodule
module \$_DFFSR_PPN_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(S || !R), .DI(D), .M(R), .Q(Q)); endmodule
module \$_DFFSR_PPP_ (input C, S, R, D, output Q); TRELLIS_FF #(.GSR("DISABLED"), .CEMUX("1"), .CLKMUX("CLK"), .LSRMODE("PRLD"), .LSRMUX("LSR"), .REGSET("RESET"), .SRMODE("ASYNC"))  _TECHMAP_REPLACE_ (.CLK(C), .LSR(S || R), .DI(D), .M(!R), .Q(Q)); endmodule
`endif

`include "cells_ff.vh"
`include "cells_io.vh"

`ifndef NO_LUT
module \$lut (A, Y);
    parameter WIDTH = 0;
    parameter LUT = 0;

    input [WIDTH-1:0] A;
    output Y;

    generate
        if (WIDTH == 1) begin
            localparam [15:0] INIT = {{8{LUT[1]}}, {8{LUT[0]}}};
            LUT4 #(.INIT(INIT)) _TECHMAP_REPLACE_ (.Z(Y),
                .A(1'b0), .B(1'b0), .C(1'b0), .D(A[0]));
        end else
        if (WIDTH == 2) begin
            localparam [15:0] INIT = {{4{LUT[3]}}, {4{LUT[2]}}, {4{LUT[1]}}, {4{LUT[0]}}};
            LUT4 #(.INIT(INIT)) _TECHMAP_REPLACE_ (.Z(Y),
                .A(1'b0), .B(1'b0), .C(A[0]), .D(A[1]));
        end else
        if (WIDTH == 3) begin
            localparam [15:0] INIT = {{2{LUT[7]}}, {2{LUT[6]}}, {2{LUT[5]}}, {2{LUT[4]}}, {2{LUT[3]}}, {2{LUT[2]}}, {2{LUT[1]}}, {2{LUT[0]}}};
            LUT4 #(.INIT(INIT)) _TECHMAP_REPLACE_ (.Z(Y),
                .A(1'b0), .B(A[0]), .C(A[1]), .D(A[2]));
        end else
        if (WIDTH == 4) begin
            LUT4 #(.INIT(LUT)) _TECHMAP_REPLACE_ (.Z(Y),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
        `ifndef NO_PFUMUX
        end else
        if (WIDTH == 5) begin
            wire f0, f1;
            LUT4 #(.INIT(LUT[15: 0])) lut0 (.Z(f0),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            LUT4 #(.INIT(LUT[31:16])) lut1 (.Z(f1),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            PFUMX mux5(.ALUT(f1), .BLUT(f0), .C0(A[4]), .Z(Y));
        end else
        if (WIDTH == 6) begin
            wire f0, f1, f2, f3, g0, g1;
            LUT4 #(.INIT(LUT[15: 0])) lut0 (.Z(f0),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            LUT4 #(.INIT(LUT[31:16])) lut1 (.Z(f1),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));

            LUT4 #(.INIT(LUT[47:32])) lut2 (.Z(f2),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            LUT4 #(.INIT(LUT[63:48])) lut3 (.Z(f3),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));

            PFUMX mux50(.ALUT(f1), .BLUT(f0), .C0(A[4]), .Z(g0));
            PFUMX mux51(.ALUT(f3), .BLUT(f2), .C0(A[4]), .Z(g1));
            L6MUX21 mux6 (.D0(g0), .D1(g1), .SD(A[5]), .Z(Y));
        end else
        if (WIDTH == 7) begin
            wire f0, f1, f2, f3, f4, f5, f6, f7, g0, g1, g2, g3, h0, h1;
            LUT4 #(.INIT(LUT[15: 0])) lut0 (.Z(f0),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            LUT4 #(.INIT(LUT[31:16])) lut1 (.Z(f1),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));

            LUT4 #(.INIT(LUT[47:32])) lut2 (.Z(f2),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            LUT4 #(.INIT(LUT[63:48])) lut3 (.Z(f3),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));

            LUT4 #(.INIT(LUT[79:64])) lut4 (.Z(f4),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            LUT4 #(.INIT(LUT[95:80])) lut5 (.Z(f5),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));

            LUT4 #(.INIT(LUT[111: 96])) lut6 (.Z(f6),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));
            LUT4 #(.INIT(LUT[127:112])) lut7 (.Z(f7),
                .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3]));

            PFUMX mux50(.ALUT(f1), .BLUT(f0), .C0(A[4]), .Z(g0));
            PFUMX mux51(.ALUT(f3), .BLUT(f2), .C0(A[4]), .Z(g1));
            PFUMX mux52(.ALUT(f5), .BLUT(f4), .C0(A[4]), .Z(g2));
            PFUMX mux53(.ALUT(f7), .BLUT(f6), .C0(A[4]), .Z(g3));
            L6MUX21 mux60 (.D0(g0), .D1(g1), .SD(A[5]), .Z(h0));
            L6MUX21 mux61 (.D0(g2), .D1(g3), .SD(A[5]), .Z(h1));
            L6MUX21 mux7  (.D0(h0), .D1(h1), .SD(A[6]), .Z(Y));
        `endif
        end else begin
            wire _TECHMAP_FAIL_ = 1;
        end
    endgenerate
endmodule
`endif
unsigned) return ValueRef; function GetParamParent(Inst : ValueRef) return ValueRef; function GetFirstParam(Fn : ValueRef) return ValueRef; function GetLastParam(Fn : ValueRef) return ValueRef; function GetNextParam(Arg : ValueRef) return ValueRef; function GetPreviousParam(Arg : ValueRef) return ValueRef; procedure AddAttribute(Arg : ValueRef; PA : Attribute); procedure RemoveAttribute(Arg : ValueRef; PA : Attribute); procedure SetParamAlignment(Arg : ValueRef; align : unsigned); -- Metadata -- Obtain a MDString value from a context. -- The returned instance corresponds to the llvm::MDString class. -- The instance is specified by string data of a specified length. The -- string content is copied, so the backing memory can be freed after -- this function returns. function MDStringInContext(C : ContextRef; Str : Cstring; Len : unsigned) return ValueRef; -- Obtain a MDString value from the global context. function MDString(Str : Cstring; Len : unsigned) return ValueRef; -- Obtain a MDNode value from a context. -- The returned value corresponds to the llvm::MDNode class. function MDNodeInContext (C : ContextRef; Vals : ValueRefArray; Count : unsigned) return ValueRef; -- Obtain a MDNode value from the global context. function MDNode(Vals : ValueRefArray; Count : unsigned) return ValueRef; -- Obtain the underlying string from a MDString value. -- @param V Instance to obtain string from. -- @param Len Memory address which will hold length of returned string. -- @return String data in MDString. function GetMDString(V : ValueRef; Len : access unsigned) return Cstring; -- Obtain the number of operands from an MDNode value. -- @param V MDNode to get number of operands from. -- @return Number of operands of the MDNode. function GetMDNodeNumOperands(V : ValueRef) return unsigned; -- Obtain the given MDNode's operands. -- The passed LLVMValueRef pointer should point to enough memory to hold -- all of the operands of the given MDNode (see LLVMGetMDNodeNumOperands) -- as LLVMValueRefs. This memory will be populated with the LLVMValueRefs -- of the MDNode's operands. -- @param V MDNode to get the operands from. -- @param Dest Destination array for operands. procedure GetMDNodeOperands(V : ValueRef; Dest : ValueRefArray); procedure MDNodeReplaceOperandWith (N : ValueRef; I : unsigned; V : ValueRef); -- Operations on basic blocks function BasicBlockAsValue(BB : BasicBlockRef) return ValueRef; function ValueIsBasicBlock(Val : ValueRef) return int; function ValueAsBasicBlock(Val : ValueRef) return BasicBlockRef; function GetBasicBlockParent(BB : BasicBlockRef) return ValueRef; function CountBasicBlocks(Fn : ValueRef) return unsigned; procedure GetBasicBlocks(Fn : ValueRef; BasicBlocks : BasicBlockRefArray); function GetFirstBasicBlock(Fn : ValueRef) return BasicBlockRef; function GetLastBasicBlock(Fn : ValueRef) return BasicBlockRef; function GetNextBasicBlock(BB : BasicBlockRef) return BasicBlockRef; function GetPreviousBasicBlock(BB : BasicBlockRef) return BasicBlockRef; function GetEntryBasicBlock(Fn : ValueRef) return BasicBlockRef; function AppendBasicBlock(Fn : ValueRef; Name : Cstring) return BasicBlockRef; function InsertBasicBlock(InsertBeforeBB : BasicBlockRef; Name : Cstring) return BasicBlockRef; procedure DeleteBasicBlock(BB : BasicBlockRef); -- Operations on instructions -- Determine whether an instruction has any metadata attached. function HasMetadata(Val: ValueRef) return Bool; -- Return metadata associated with an instruction value. function GetMetadata(Val : ValueRef; KindID : unsigned) return ValueRef; -- Set metadata associated with an instruction value. procedure SetMetadata(Val : ValueRef; KindID : unsigned; Node : ValueRef); function GetInstructionParent(Inst : ValueRef) return BasicBlockRef; function GetFirstInstruction(BB : BasicBlockRef) return ValueRef; function GetLastInstruction(BB : BasicBlockRef) return ValueRef; function GetNextInstruction(Inst : ValueRef) return ValueRef; function GetPreviousInstruction(Inst : ValueRef) return ValueRef; -- Operations on call sites procedure SetInstructionCallConv(Instr : ValueRef; CC : unsigned); function GetInstructionCallConv(Instr : ValueRef) return unsigned; procedure AddInstrAttribute(Instr : ValueRef; index : unsigned; Attr : Attribute); procedure RemoveInstrAttribute(Instr : ValueRef; index : unsigned; Attr : Attribute); procedure SetInstrParamAlignment(Instr : ValueRef; index : unsigned; align : unsigned); -- Operations on call instructions (only) function IsTailCall(CallInst : ValueRef) return int; procedure SetTailCall(CallInst : ValueRef; IsTailCall : int); -- Operations on phi nodes procedure AddIncoming(PhiNode : ValueRef; IncomingValues : ValueRefArray; IncomingBlocks : BasicBlockRefArray; Count : unsigned); function CountIncoming(PhiNode : ValueRef) return unsigned; function GetIncomingValue(PhiNode : ValueRef; Index : unsigned) return ValueRef; function GetIncomingBlock(PhiNode : ValueRef; Index : unsigned) return BasicBlockRef; -- Instruction builders ---------------------------------------------- -- An instruction builder represents a point within a basic block, -- and is the exclusive means of building instructions using the C -- interface. function CreateBuilder return BuilderRef; procedure PositionBuilder(Builder : BuilderRef; Block : BasicBlockRef; Instr : ValueRef); procedure PositionBuilderBefore(Builder : BuilderRef; Instr : ValueRef); procedure PositionBuilderAtEnd(Builder : BuilderRef; Block : BasicBlockRef); function GetInsertBlock(Builder : BuilderRef) return BasicBlockRef; procedure DisposeBuilder(Builder : BuilderRef); -- Terminators function BuildRetVoid(Builder : BuilderRef) return ValueRef; function BuildRet(Builder : BuilderRef; V : ValueRef) return ValueRef; function BuildBr(Builder : BuilderRef; Dest : BasicBlockRef) return ValueRef; function BuildCondBr(Builder : BuilderRef; If_Br : ValueRef; Then_Br : BasicBlockRef; Else_Br : BasicBlockRef) return ValueRef; function BuildSwitch(Builder : BuilderRef; V : ValueRef; Else_Br : BasicBlockRef; NumCases : unsigned) return ValueRef; function BuildInvoke(Builder : BuilderRef; Fn : ValueRef; Args : ValueRefArray; NumArgs : unsigned; Then_Br : BasicBlockRef; Catch : BasicBlockRef; Name : Cstring) return ValueRef; function BuildUnwind(Builder : BuilderRef) return ValueRef; function BuildUnreachable(Builder : BuilderRef) return ValueRef; -- Add a case to the switch instruction procedure AddCase(Switch : ValueRef; OnVal : ValueRef; Dest : BasicBlockRef); -- Arithmetic function BuildAdd(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildNSWAdd(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildNUWAdd(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildFAdd(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildSub(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildNSWSub(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildNUWSub(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildFSub(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildMul(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildFMul(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildUDiv(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildSDiv(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildFDiv(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildURem(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildSRem(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildFRem(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildShl(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildLShr(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildAShr(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildAnd(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildOr(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildXor(Builder : BuilderRef; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildNeg(Builder : BuilderRef; V : ValueRef; Name : Cstring) return ValueRef; function BuildFNeg(Builder : BuilderRef; V : ValueRef; Name : Cstring) return ValueRef; function BuildNot(Builder : BuilderRef; V : ValueRef; Name : Cstring) return ValueRef; -- Memory function BuildMalloc(Builder : BuilderRef; Ty : TypeRef; Name : Cstring) return ValueRef; function BuildArrayMalloc(Builder : BuilderRef; Ty : TypeRef; Val : ValueRef; Name : Cstring) return ValueRef; function BuildAlloca(Builder : BuilderRef; Ty : TypeRef; Name : Cstring) return ValueRef; function BuildArrayAlloca(Builder : BuilderRef; Ty : TypeRef; Val : ValueRef; Name : Cstring) return ValueRef; function BuildFree(Builder : BuilderRef; PointerVal : ValueRef) return ValueRef; function BuildLoad(Builder : BuilderRef; PointerVal : ValueRef; Name : Cstring) return ValueRef; function BuildStore(Builder : BuilderRef; Val : ValueRef; Ptr : ValueRef) return ValueRef; function BuildGEP(Builder : BuilderRef; Pointer : ValueRef; Indices : ValueRefArray; NumIndices : unsigned; Name : Cstring) return ValueRef; -- Casts function BuildTrunc(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildZExt(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildSExt(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildFPToUI(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildFPToSI(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildUIToFP(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildSIToFP(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildFPTrunc(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildFPExt(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildPtrToInt(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildIntToPtr(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; function BuildBitCast(Builder : BuilderRef; Val : ValueRef; DestTy : TypeRef; Name : Cstring) return ValueRef; -- Comparisons function BuildICmp(Builder : BuilderRef; Op : IntPredicate; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; function BuildFCmp(Builder : BuilderRef; Op : RealPredicate; LHS : ValueRef; RHS : ValueRef; Name : Cstring) return ValueRef; -- Miscellaneous instructions function BuildPhi(Builder : BuilderRef; Ty : TypeRef; Name : Cstring) return ValueRef; function BuildCall(Builder : BuilderRef; Fn : ValueRef; Args : ValueRefArray; NumArgs : unsigned; Name : Cstring) return ValueRef; function BuildSelect(Builder : BuilderRef; If_Sel : ValueRef; Then_Sel : ValueRef; Else_Sel : ValueRef; Name : Cstring) return ValueRef; function BuildVAArg(Builder : BuilderRef; List : ValueRef; Ty : TypeRef; Name : Cstring) return ValueRef; function BuildExtractElement(Builder : BuilderRef; VecVal : ValueRef; Index : ValueRef; Name : Cstring) return ValueRef; function BuildInsertElement(Builder : BuilderRef; VecVal : ValueRef; EltVal : ValueRef; Index : ValueRef; Name : Cstring) return ValueRef; function BuildShuffleVector(Builder : BuilderRef; V1 : ValueRef; V2 : ValueRef; Mask : ValueRef; Name : Cstring) return ValueRef; -- Memory buffers ---------------------------------------------------- function CreateMemoryBufferWithContentsOfFile (Path : Cstring; OutMemBuf : access MemoryBufferRef; OutMessage : access Cstring) return int; function CreateMemoryBufferWithSTDIN (OutMemBuf : access MemoryBufferRef; OutMessage : access Cstring) return int; procedure DisposeMemoryBuffer(MemBuf : MemoryBufferRef); -- Pass Managers ----------------------------------------------------- -- Constructs a new whole-module pass pipeline. This type of pipeline is -- suitable for link-time optimization and whole-module transformations. -- See llvm::PassManager::PassManager. function CreatePassManager return PassManagerRef; -- Constructs a new function-by-function pass pipeline over the module -- provider. It does not take ownership of the module provider. This type of -- pipeline is suitable for code generation and JIT compilation tasks. -- See llvm::FunctionPassManager::FunctionPassManager. function CreateFunctionPassManagerForModule(M : ModuleRef) return PassManagerRef; -- Initializes, executes on the provided module, and finalizes all of the -- passes scheduled in the pass manager. Returns 1 if any of the passes -- modified the module, 0 otherwise. See llvm::PassManager::run(Module&). function RunPassManager(PM : PassManagerRef; M : ModuleRef) return int; -- Initializes all of the function passes scheduled in the function pass -- manager. Returns 1 if any of the passes modified the module, 0 otherwise. -- See llvm::FunctionPassManager::doInitialization. function InitializeFunctionPassManager(FPM : PassManagerRef) return int; -- Executes all of the function passes scheduled in the function -- pass manager on the provided function. Returns 1 if any of the -- passes modified the function, false otherwise. -- See llvm::FunctionPassManager::run(Function&). function RunFunctionPassManager (FPM : PassManagerRef; F : ValueRef) return int; -- Finalizes all of the function passes scheduled in in the function pass -- manager. Returns 1 if any of the passes modified the module, 0 otherwise. -- See llvm::FunctionPassManager::doFinalization. function FinalizeFunctionPassManager(FPM : PassManagerRef) return int; -- Frees the memory of a pass pipeline. For function pipelines, -- does not free the module provider. -- See llvm::PassManagerBase::~PassManagerBase. procedure DisposePassManager(PM : PassManagerRef); private pragma Import (C, ContextCreate, "LLVMContextCreate"); pragma Import (C, GetGlobalContext, "LLVMGetGlobalContext"); pragma Import (C, ContextDispose, "LLVMContextDispose"); pragma Import (C, GetMDKindIDInContext, "LLVMGetMDKindIDInContext"); pragma Import (C, GetMDKindID, "LLVMGetMDKindID"); pragma Import (C, DisposeMessage, "LLVMDisposeMessage"); pragma Import (C, ModuleCreateWithName, "LLVMModuleCreateWithName"); pragma Import (C, DisposeModule, "LLVMDisposeModule"); pragma Import (C, GetDataLayout, "LLVMGetDataLayout"); pragma Import (C, SetDataLayout, "LLVMSetDataLayout"); pragma Import (C, GetTarget, "LLVMGetTarget"); pragma Import (C, SetTarget, "LLVMSetTarget"); pragma Import (C, DumpModule, "LLVMDumpModule"); pragma Import (C, PrintModuleToFile, "LLVMPrintModuleToFile"); pragma Import (C, GetTypeKind, "LLVMGetTypeKind"); pragma Import (C, Int1Type, "LLVMInt1Type"); pragma Import (C, Int8Type, "LLVMInt8Type"); pragma Import (C, Int16Type, "LLVMInt16Type"); pragma Import (C, Int32Type, "LLVMInt32Type"); pragma Import (C, Int64Type, "LLVMInt64Type"); pragma Import (C, IntType, "LLVMIntType"); pragma Import (C, GetIntTypeWidth, "LLVMGetIntTypeWidth"); pragma Import (C, MetadataType, "LLVMMetadataType_extra"); pragma Import (C, FloatType, "LLVMFloatType"); pragma Import (C, DoubleType, "LLVMDoubleType"); pragma Import (C, X86FP80Type, "LLVMX86FP80Type"); pragma Import (C, FP128Type, "LLVMFP128Type"); pragma Import (C, PPCFP128Type, "LLVMPPCFP128Type"); pragma Import (C, FunctionType, "LLVMFunctionType"); pragma Import (C, IsFunctionVarArg, "LLVMIsFunctionVarArg"); pragma Import (C, GetReturnType, "LLVMGetReturnType"); pragma Import (C, CountParamTypes, "LLVMCountParamTypes"); pragma Import (C, GetParamTypes, "LLVMGetParamTypes"); pragma Import (C, StructType, "LLVMStructType"); pragma Import (C, StructCreateNamed, "LLVMStructCreateNamed"); pragma Import (C, StructSetBody, "LLVMStructSetBody"); pragma Import (C, CountStructElementTypes, "LLVMCountStructElementTypes"); pragma Import (C, GetStructElementTypes, "LLVMGetStructElementTypes"); pragma Import (C, IsPackedStruct, "LLVMIsPackedStruct"); pragma Import (C, ArrayType, "LLVMArrayType"); pragma Import (C, PointerType, "LLVMPointerType"); pragma Import (C, VectorType, "LLVMVectorType"); pragma Import (C, GetElementType, "LLVMGetElementType"); pragma Import (C, GetArrayLength, "LLVMGetArrayLength"); pragma Import (C, GetPointerAddressSpace, "LLVMGetPointerAddressSpace"); pragma Import (C, GetVectorSize, "LLVMGetVectorSize"); pragma Import (C, VoidType, "LLVMVoidType"); pragma Import (C, LabelType, "LLVMLabelType"); pragma Import (C, DumpType, "LLVMDumpType"); pragma Import (C, TypeOf, "LLVMTypeOf"); pragma Import (C, GetValueName, "LLVMGetValueName"); pragma Import (C, SetValueName, "LLVMSetValueName"); pragma Import (C, DumpValue, "LLVMDumpValue"); pragma Import (C, ConstNull, "LLVMConstNull"); pragma Import (C, ConstAllOnes, "LLVMConstAllOnes"); pragma Import (C, GetUndef, "LLVMGetUndef"); pragma Import (C, IsConstant, "LLVMIsConstant"); pragma Import (C, IsNull, "LLVMIsNull"); pragma Import (C, IsUndef, "LLVMIsUndef"); pragma Import (C, IsAInstruction, "LLVMIsAInstruction"); pragma Import (C, ConstInt, "LLVMConstInt"); pragma Import (C, ConstReal, "LLVMConstReal"); pragma Import (C, ConstIntGetZExtValue, "LLVMConstIntGetZExtValue"); pragma Import (C, ConstRealOfString, "LLVMConstRealOfString"); pragma Import (C, ConstString, "LLVMConstString"); pragma Import (C, ConstArray, "LLVMConstArray"); pragma Import (C, ConstStruct, "LLVMConstStruct"); pragma Import (C, ConstNamedStruct, "LLVMConstNamedStruct"); pragma Import (C, ConstVector, "LLVMConstVector"); pragma Import (C, SizeOf, "LLVMSizeOf"); pragma Import (C, AlignOf, "LLVMAlignOf"); pragma Import (C, ConstNeg, "LLVMConstNeg"); pragma Import (C, ConstNot, "LLVMConstNot"); pragma Import (C, ConstAdd, "LLVMConstAdd"); pragma Import (C, ConstSub, "LLVMConstSub"); pragma Import (C, ConstMul, "LLVMConstMul"); pragma Import (C, ConstUDiv, "LLVMConstUDiv"); pragma Import (C, ConstSDiv, "LLVMConstSDiv"); pragma Import (C, ConstFDiv, "LLVMConstFDiv"); pragma Import (C, ConstURem, "LLVMConstURem"); pragma Import (C, ConstSRem, "LLVMConstSRem"); pragma Import (C, ConstFRem, "LLVMConstFRem"); pragma Import (C, ConstAnd, "LLVMConstAnd"); pragma Import (C, ConstOr, "LLVMConstOr"); pragma Import (C, ConstXor, "LLVMConstXor"); pragma Import (C, ConstICmp, "LLVMConstICmp"); pragma Import (C, ConstFCmp, "LLVMConstFCmp"); pragma Import (C, ConstShl, "LLVMConstShl"); pragma Import (C, ConstLShr, "LLVMConstLShr"); pragma Import (C, ConstAShr, "LLVMConstAShr"); pragma Import (C, ConstGEP, "LLVMConstGEP"); pragma Import (C, ConstTrunc, "LLVMConstTrunc"); pragma Import (C, ConstSExt, "LLVMConstSExt"); pragma Import (C, ConstZExt, "LLVMConstZExt"); pragma Import (C, ConstFPTrunc, "LLVMConstFPTrunc"); pragma Import (C, ConstFPExt, "LLVMConstFPExt"); pragma Import (C, ConstUIToFP, "LLVMConstUIToFP"); pragma Import (C, ConstSIToFP, "LLVMConstSIToFP"); pragma Import (C, ConstFPToUI, "LLVMConstFPToUI"); pragma Import (C, ConstFPToSI, "LLVMConstFPToSI"); pragma Import (C, ConstPtrToInt, "LLVMConstPtrToInt"); pragma Import (C, ConstIntToPtr, "LLVMConstIntToPtr"); pragma Import (C, ConstBitCast, "LLVMConstBitCast"); pragma Import (C, ConstTruncOrBitCast, "LLVMConstTruncOrBitCast"); pragma Import (C, ConstSelect, "LLVMConstSelect"); pragma Import (C, ConstExtractElement, "LLVMConstExtractElement"); pragma Import (C, ConstInsertElement, "LLVMConstInsertElement"); pragma Import (C, ConstShuffleVector, "LLVMConstShuffleVector"); pragma Import (C, GetGlobalParent, "LLVMGetGlobalParent"); pragma Import (C, IsDeclaration, "LLVMIsDeclaration"); pragma Import (C, GetLinkage, "LLVMGetLinkage"); pragma Import (C, SetLinkage, "LLVMSetLinkage"); pragma Import (C, GetSection, "LLVMGetSection"); pragma Import (C, SetSection, "LLVMSetSection"); pragma Import (C, GetVisibility, "LLVMGetVisibility"); pragma Import (C, SetVisibility, "LLVMSetVisibility"); pragma Import (C, GetAlignment, "LLVMGetAlignment"); pragma Import (C, SetAlignment, "LLVMSetAlignment"); pragma Import (C, AddGlobal, "LLVMAddGlobal"); pragma Import (C, GetNamedGlobal, "LLVMGetNamedGlobal"); pragma Import (C, GetFirstGlobal, "LLVMGetFirstGlobal"); pragma Import (C, GetLastGlobal, "LLVMGetLastGlobal"); pragma Import (C, GetNextGlobal, "LLVMGetNextGlobal"); pragma Import (C, GetPreviousGlobal, "LLVMGetPreviousGlobal"); pragma Import (C, DeleteGlobal, "LLVMDeleteGlobal"); pragma Import (C, GetInitializer, "LLVMGetInitializer"); pragma Import (C, SetInitializer, "LLVMSetInitializer"); pragma Import (C, IsThreadLocal, "LLVMIsThreadLocal"); pragma Import (C, SetThreadLocal, "LLVMSetThreadLocal"); pragma Import (C, IsGlobalConstant, "LLVMIsGlobalConstant"); pragma Import (C, SetGlobalConstant, "LLVMSetGlobalConstant"); pragma Import (C, GetNamedMetadataNumOperands, "LLVMGetNamedMetadataNumOperands"); pragma Import (C, GetNamedMetadataOperands, "LLVMGetNamedMetadataOperands"); pragma Import (C, AddNamedMetadataOperand, "LLVMAddNamedMetadataOperand"); pragma Import (C, AddFunction, "LLVMAddFunction"); pragma Import (C, GetNamedFunction, "LLVMGetNamedFunction"); pragma Import (C, GetFirstFunction, "LLVMGetFirstFunction"); pragma Import (C, GetLastFunction, "LLVMGetLastFunction"); pragma Import (C, GetNextFunction, "LLVMGetNextFunction"); pragma Import (C, GetPreviousFunction, "LLVMGetPreviousFunction"); pragma Import (C, DeleteFunction, "LLVMDeleteFunction"); pragma Import (C, GetIntrinsicID, "LLVMGetIntrinsicID"); pragma Import (C, GetFunctionCallConv, "LLVMGetFunctionCallConv"); pragma Import (C, SetFunctionCallConv, "LLVMSetFunctionCallConv"); pragma Import (C, GetGC, "LLVMGetGC"); pragma Import (C, SetGC, "LLVMSetGC"); pragma Import (C, AddFunctionAttr, "LLVMAddFunctionAttr"); pragma import (C, AddTargetDependentFunctionAttr, "LLVMAddTargetDependentFunctionAttr"); pragma Import (C, GetFunctionAttr, "LLVMGetFunctionAttr"); pragma Import (C, RemoveFunctionAttr, "LLVMRemoveFunctionAttr"); pragma Import (C, CountParams, "LLVMCountParams"); pragma Import (C, GetParams, "LLVMGetParams"); pragma Import (C, GetParam, "LLVMGetParam"); pragma Import (C, GetParamParent, "LLVMGetParamParent"); pragma Import (C, GetFirstParam, "LLVMGetFirstParam"); pragma Import (C, GetLastParam, "LLVMGetLastParam"); pragma Import (C, GetNextParam, "LLVMGetNextParam"); pragma Import (C, GetPreviousParam, "LLVMGetPreviousParam"); pragma Import (C, AddAttribute, "LLVMAddAttribute"); pragma Import (C, RemoveAttribute, "LLVMRemoveAttribute"); pragma Import (C, SetParamAlignment, "LLVMSetParamAlignment"); pragma Import (C, MDStringInContext, "LLVMMDStringInContext"); pragma Import (C, MDString, "LLVMMDString"); pragma Import (C, MDNodeInContext, "LLVMMDNodeInContext"); pragma Import (C, MDNode, "LLVMMDNode"); pragma Import (C, GetMDString, "LLVMGetMDString"); pragma Import (C, GetMDNodeNumOperands, "LLVMGetMDNodeNumOperands"); pragma Import (C, GetMDNodeOperands, "LLVMGetMDNodeOperands"); pragma Import (C, MDNodeReplaceOperandWith, "LLVMMDNodeReplaceOperandWith_extra"); pragma Import (C, BasicBlockAsValue, "LLVMBasicBlockAsValue"); pragma Import (C, ValueIsBasicBlock, "LLVMValueIsBasicBlock"); pragma Import (C, ValueAsBasicBlock, "LLVMValueAsBasicBlock"); pragma Import (C, GetBasicBlockParent, "LLVMGetBasicBlockParent"); pragma Import (C, CountBasicBlocks, "LLVMCountBasicBlocks"); pragma Import (C, GetBasicBlocks, "LLVMGetBasicBlocks"); pragma Import (C, GetFirstBasicBlock, "LLVMGetFirstBasicBlock"); pragma Import (C, GetLastBasicBlock, "LLVMGetLastBasicBlock"); pragma Import (C, GetNextBasicBlock, "LLVMGetNextBasicBlock"); pragma Import (C, GetPreviousBasicBlock, "LLVMGetPreviousBasicBlock"); pragma Import (C, GetEntryBasicBlock, "LLVMGetEntryBasicBlock"); pragma Import (C, AppendBasicBlock, "LLVMAppendBasicBlock"); pragma Import (C, InsertBasicBlock, "LLVMInsertBasicBlock"); pragma Import (C, DeleteBasicBlock, "LLVMDeleteBasicBlock"); pragma Import (C, HasMetadata, "LLVMHasMetadata"); pragma Import (C, GetMetadata, "LLVMGetMetadata"); pragma Import (C, SetMetadata, "LLVMSetMetadata"); pragma Import (C, GetInstructionParent, "LLVMGetInstructionParent"); pragma Import (C, GetFirstInstruction, "LLVMGetFirstInstruction"); pragma Import (C, GetLastInstruction, "LLVMGetLastInstruction"); pragma Import (C, GetNextInstruction, "LLVMGetNextInstruction"); pragma Import (C, GetPreviousInstruction, "LLVMGetPreviousInstruction"); pragma Import (C, SetInstructionCallConv, "LLVMSetInstructionCallConv"); pragma Import (C, GetInstructionCallConv, "LLVMGetInstructionCallConv"); pragma Import (C, AddInstrAttribute, "LLVMAddInstrAttribute"); pragma Import (C, RemoveInstrAttribute, "LLVMRemoveInstrAttribute"); pragma Import (C, SetInstrParamAlignment, "LLVMSetInstrParamAlignment"); pragma Import (C, IsTailCall, "LLVMIsTailCall"); pragma Import (C, SetTailCall, "LLVMSetTailCall"); pragma Import (C, AddIncoming, "LLVMAddIncoming"); pragma Import (C, CountIncoming, "LLVMCountIncoming"); pragma Import (C, GetIncomingValue, "LLVMGetIncomingValue"); pragma Import (C, GetIncomingBlock, "LLVMGetIncomingBlock"); pragma Import (C, CreateBuilder, "LLVMCreateBuilder"); pragma Import (C, PositionBuilder, "LLVMPositionBuilder"); pragma Import (C, PositionBuilderBefore, "LLVMPositionBuilderBefore"); pragma Import (C, PositionBuilderAtEnd, "LLVMPositionBuilderAtEnd"); pragma Import (C, GetInsertBlock, "LLVMGetInsertBlock"); pragma Import (C, DisposeBuilder, "LLVMDisposeBuilder"); -- Terminators pragma Import (C, BuildRetVoid, "LLVMBuildRetVoid"); pragma Import (C, BuildRet, "LLVMBuildRet"); pragma Import (C, BuildBr, "LLVMBuildBr"); pragma Import (C, BuildCondBr, "LLVMBuildCondBr"); pragma Import (C, BuildSwitch, "LLVMBuildSwitch"); pragma Import (C, BuildInvoke, "LLVMBuildInvoke"); pragma Import (C, BuildUnwind, "LLVMBuildUnwind"); pragma Import (C, BuildUnreachable, "LLVMBuildUnreachable"); -- Add a case to the switch instruction pragma Import (C, AddCase, "LLVMAddCase"); -- Arithmetic pragma Import (C, BuildAdd, "LLVMBuildAdd"); pragma Import (C, BuildNSWAdd, "LLVMBuildNSWAdd"); pragma Import (C, BuildNUWAdd, "LLVMBuildNUWAdd"); pragma Import (C, BuildFAdd, "LLVMBuildFAdd"); pragma Import (C, BuildSub, "LLVMBuildSub"); pragma Import (C, BuildNSWSub, "LLVMBuildNSWSub"); pragma Import (C, BuildNUWSub, "LLVMBuildNUWSub"); pragma Import (C, BuildFSub, "LLVMBuildFSub"); pragma Import (C, BuildMul, "LLVMBuildMul"); pragma Import (C, BuildFMul, "LLVMBuildFMul"); pragma Import (C, BuildUDiv, "LLVMBuildUDiv"); pragma Import (C, BuildSDiv, "LLVMBuildSDiv"); pragma Import (C, BuildFDiv, "LLVMBuildFDiv"); pragma Import (C, BuildURem, "LLVMBuildURem"); pragma Import (C, BuildSRem, "LLVMBuildSRem"); pragma Import (C, BuildFRem, "LLVMBuildFRem"); pragma Import (C, BuildShl, "LLVMBuildShl"); pragma Import (C, BuildLShr, "LLVMBuildLShr"); pragma Import (C, BuildAShr, "LLVMBuildAShr"); pragma Import (C, BuildAnd, "LLVMBuildAnd"); pragma Import (C, BuildOr, "LLVMBuildOr"); pragma Import (C, BuildXor, "LLVMBuildXor"); pragma Import (C, BuildNeg, "LLVMBuildNeg"); pragma Import (C, BuildFNeg, "LLVMBuildFNeg"); pragma Import (C, BuildNot, "LLVMBuildNot"); -- Memory pragma Import (C, BuildMalloc, "LLVMBuildMalloc"); pragma Import (C, BuildArrayMalloc, "LLVMBuildArrayMalloc"); pragma Import (C, BuildAlloca, "LLVMBuildAlloca"); pragma Import (C, BuildArrayAlloca, "LLVMBuildArrayAlloca"); pragma Import (C, BuildFree, "LLVMBuildFree"); pragma Import (C, BuildLoad, "LLVMBuildLoad"); pragma Import (C, BuildStore, "LLVMBuildStore"); pragma Import (C, BuildGEP, "LLVMBuildGEP"); -- Casts pragma Import (C, BuildTrunc, "LLVMBuildTrunc"); pragma Import (C, BuildZExt, "LLVMBuildZExt"); pragma Import (C, BuildSExt, "LLVMBuildSExt"); pragma Import (C, BuildFPToUI, "LLVMBuildFPToUI"); pragma Import (C, BuildFPToSI, "LLVMBuildFPToSI"); pragma Import (C, BuildUIToFP, "LLVMBuildUIToFP"); pragma Import (C, BuildSIToFP, "LLVMBuildSIToFP"); pragma Import (C, BuildFPTrunc, "LLVMBuildFPTrunc"); pragma Import (C, BuildFPExt, "LLVMBuildFPExt"); pragma Import (C, BuildPtrToInt, "LLVMBuildPtrToInt"); pragma Import (C, BuildIntToPtr, "LLVMBuildIntToPtr"); pragma Import (C, BuildBitCast, "LLVMBuildBitCast"); -- Comparisons pragma Import (C, BuildICmp, "LLVMBuildICmp"); pragma Import (C, BuildFCmp, "LLVMBuildFCmp"); -- Miscellaneous instructions pragma Import (C, BuildPhi, "LLVMBuildPhi"); pragma Import (C, BuildCall, "LLVMBuildCall"); pragma Import (C, BuildSelect, "LLVMBuildSelect"); pragma Import (C, BuildVAArg, "LLVMBuildVAArg"); pragma Import (C, BuildExtractElement, "LLVMBuildExtractElement"); pragma Import (C, BuildInsertElement, "LLVMBuildInsertElement"); pragma Import (C, BuildShuffleVector, "LLVMBuildShuffleVector"); -- Memory buffers ---------------------------------------------------- pragma Import (C, CreateMemoryBufferWithContentsOfFile, "LLVMCreateMemoryBufferWithContentsOfFile"); pragma Import (C, CreateMemoryBufferWithSTDIN, "LLVMCreateMemoryBufferWithSTDIN"); pragma Import (C, DisposeMemoryBuffer, "LLVMDisposeMemoryBuffer"); -- Pass Managers ----------------------------------------------------- pragma Import (C, CreatePassManager, "LLVMCreatePassManager"); pragma Import (C, CreateFunctionPassManagerForModule, "LLVMCreateFunctionPassManagerForModule"); pragma Import (C, RunPassManager, "LLVMRunPassManager"); pragma Import (C, InitializeFunctionPassManager, "LLVMInitializeFunctionPassManager"); pragma Import (C, RunFunctionPassManager, "LLVMRunFunctionPassManager"); pragma Import (C, FinalizeFunctionPassManager, "LLVMFinalizeFunctionPassManager"); pragma Import (C, DisposePassManager, "LLVMDisposePassManager"); end LLVM.Core;