Design Logic Online

Verilog Functions Explained: Syntax, Examples, and Difference from Tasks

モジュールと関数・タスク
佐川 直弘 | Naohiro Sagawa
By 佐川 直弘 | Naohiro Sagawa (運営者)
※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。
目次

1. What is a Verilog Function? (Basic Concept and Role)

Verilog HDL (Hardware Description Language) is a hardware description language used for designing and simulating digital circuits. Among its features, the function is a mechanism that allows you to modularize specific operations and make them reusable. Understanding Verilog functions not only improves code readability and maintainability but also leads to more efficient circuit design. In this article, we explain the basic concept of Verilog functions and how they are used in real-world design.

What is a function?

A Verilog function is a block that performs a specific calculation or operation and returns a single value. By using functions, you can reduce redundant code and make your circuit description simpler.

Key Characteristics of Functions

  • One or more inputs can be specified (only input is allowed)
  • Only one output (the function’s return value)
  • Time delays (e.g., #10) are not allowed
  • Functions must always describe combinational logic
  • Functions are defined outside of always blocks and are evaluated immediately (unlike tasks)

When to Use Verilog Functions

Verilog functions are mainly used in the following scenarios:

1. Describing Combinational Logic

Since functions return results immediately based on inputs, they are often used in combinational logic. Examples: addition, subtraction, encoders, decoders, and other arithmetic operations.

2. Improving Code Reusability

You can eliminate redundant code by summarizing frequently used logic into functions. Example: turning a complex conditional expression into a function to improve readability within a module.

3. Reducing Design Errors

By centralizing calculations or logic operations in a single function, you can reduce mistakes when modifying the code. Examples: CRC (Cyclic Redundancy Check) calculations or parity checks.

Difference Between Functions and Tasks

In Verilog, there is another construct called a task. While functions and tasks are similar, they differ in important ways:
ItemFunctionTask
OutputOnly oneMultiple allowed
InputYesYes
Local VariablesAllowedAllowed
Delay (#10)Not allowedAllowed
Usage inside alwaysAllowedNot allowed
Invocationfunction_name(arguments)task_name(arguments);

When to Use a Function

  • When you need an immediate calculation result
  • For logic that does not include delays
  • When a single return value is sufficient

When to Use a Task

  • When the process includes delays (e.g., #10)
  • When multiple outputs are required
  • For simulation/debug purposes (e.g., log output)

Summary

  • A Verilog function is a function that takes inputs and returns a single value.
  • It is best suited for describing combinational logic and cannot include delays.
  • Useful for reducing redundant code and improving readability.
  • Functions and tasks differ; choosing the right one depends on your use case.

2. How to Write a Verilog Function [Beginner-Friendly Example]

In the previous section, we covered the basic concept of Verilog functions. Here, we’ll dive into the actual syntax and how to write Verilog functions in practice.

Basic Syntax of a Function

A Verilog function is written using the following general syntax:
function [output_bit_width] function_name;
    input [input_bit_width] input1, input2, ...;
    begin
        function_name = expression;
    end
endfunction

Key Points

  • Declare with the function keyword
  • The return value is assigned to a variable with the same name as the function
  • Declare inputs using input (you cannot use output or inout)
  • Perform calculations inside begin ... end
  • Define the function outside of an always block

Simple Example of a Verilog Function

The following example shows a function that performs 8-bit addition:
module example;
    function [7:0] add_function;
        input [7:0] a, b;
        begin
            add_function = a + b;
        end
    endfunction

    reg [7:0] x, y, sum;

    initial begin
        x = 8'b00001100; // 12
        y = 8'b00000101; // 5
        sum = add_function(x, y);
        $display("Sum: %d", sum); // Sum: 17
    end
endmodule

Explanation

  • add_function takes two 8-bit inputs (a and b) and returns their sum
  • The function is called with sum = add_function(x, y); and assigns the result to sum
  • The initial block uses $display to show the result

Declaring Inputs and Outputs in a Function

Declaring Inputs

A Verilog function can only take input arguments.
function [7:0] my_function;
    input [7:0] in1, in2;
    begin
        my_function = in1 & in2; // AND operation
    end
endfunction
Note: You cannot declare output in a function. The return value is always the variable with the same name as the function.

Function with Conditional Statements

You can also use if or case statements inside a function.
function [3:0] max_function;
    input [3:0] a, b;
    begin
        if (a > b)
            max_function = a;
        else
            max_function = b;
    end
endfunction
This function returns the larger value between a and b.

Summary

  • A Verilog function is defined with the function keyword and returns a single value
  • Only input arguments are allowed (no output)
  • The return value is assigned to the variable with the same name as the function
  • if and case statements can be used for conditional logic

3. How to Use Verilog Functions [With Practical Code Examples]

In the previous section, we learned the basic syntax and how to write Verilog functions. Here, we will explain how to apply functions in real design with practical examples.

How to Call a Function

A Verilog function is called just like a regular variable assignment, using the format function_name(arg1, arg2, ...). The following example defines an 8-bit XOR function and uses it inside a module:
module function_example;
    function [7:0] xor_function;
        input [7:0] a, b;
        begin
            xor_function = a ^ b;
        end
    endfunction

    reg [7:0] x, y, result;

    initial begin
        x = 8'b11001100;
        y = 8'b10101010;
        result = xor_function(x, y); // calling the function
        $display("XOR Result: %b", result); // XOR Result: 01100110
    end
endmodule

Key Points

  • A function is called in the form variable = function(arguments);
  • It can be used inside always or initial blocks
  • Functions work as combinational logic

Using Functions in Combinational Logic

Since Verilog functions are always evaluated immediately, they are useful in building combinational logic. The following example shows a 2-to-4 decoder implemented with a function:
module decoder_example;
    function [3:0] decoder;
        input [1:0] sel;
        begin
            case (sel)
                2'b00: decoder = 4'b0001;
                2'b01: decoder = 4'b0010;
                2'b10: decoder = 4'b0100;
                2'b11: decoder = 4'b1000;
                default: decoder = 4'b0000;
            endcase
        end
    endfunction

    reg [1:0] select;
    wire [3:0] decoded_output;

    assign decoded_output = decoder(select); // using the function

    initial begin
        select = 2'b01;
        #10; // add delay to observe simulation changes
        $display("Decoded Output: %b", decoded_output); // Decoded Output: 0010
    end
endmodule

Explanation

  • The decoder function converts a 2-bit input into a 4-bit decoder output
  • Uses a case statement to decide output based on input
  • assign is used to map the function output to decoded_output → The function works as a part of combinational logic

Functions vs. Always Blocks [Comparison Table]

Both Verilog functions and always blocks are used to describe logic, but their purpose and restrictions differ.
ItemFunctionAlways Block
Definition LocationOutside always blocksInside always blocks
Inputsinput onlyreg or wire can be used
OutputsOnly one valueCan update multiple values
Delay (#10)Not allowedAllowed
State RetentionNot allowed (always immediate evaluation)Allowed (can work as flip-flops)
Main UsageCombinational logicSequential logic or event-driven processing

Key Guidelines

  • Use functions to simplify simple logic operations (combinational logic)
  • Use always blocks for circuits that hold state (e.g., flip-flops)
  • If you need delays (like #10), use always blocks instead of functions

Summary: How to Use Verilog Functions

✅ Call a function with function_name(arguments) ✅ Functions are best for combinational logic and differ from always blocks ✅ Use case or if statements to describe flexible logic ✅ Useful for decoders, arithmetic operations, and more

4. Practical Applications of Verilog Functions (Decoder and ALU Design)

So far, we have learned the basic syntax and usage of Verilog functions. In this section, we will look at how to apply functions in real digital circuit design, using decoders and ALUs (Arithmetic Logic Units) as examples.

Function Implementation of a Decoder (2-to-4 Decoder)

A decoder is a circuit that converts a small number of input bits into a larger number of output bits. For example, a 2-to-4 decoder converts a 2-bit input into a 4-bit output. Let’s implement this using a function:
module decoder_example;
    function [3:0] decoder;
        input [1:0] sel;
        begin
            case (sel)
                2'b00: decoder = 4'b0001;
                2'b01: decoder = 4'b0010;
                2'b10: decoder = 4'b0100;
                2'b11: decoder = 4'b1000;
                default: decoder = 4'b0000;
            endcase
        end
    endfunction

    reg [1:0] select;
    wire [3:0] decoded_output;

    assign decoded_output = decoder(select); // using the function

    initial begin
        select = 2'b00; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b01; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b10; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b11; #10;
        $display("Decoded Output: %b", decoded_output);
    end
endmodule

Function Implementation of an ALU (Addition, Subtraction, AND, OR)

An ALU (Arithmetic Logic Unit) is the core circuit of a CPU, responsible for performing arithmetic and logic operations such as addition, subtraction, AND, and OR. Here, we design a simple 8-bit ALU using a Verilog function:
module alu_example;
    function [7:0] alu;
        input [7:0] a, b;
        input [1:0] op; // 2-bit control signal
        begin
            case (op)
                2'b00: alu = a + b; // Addition
                2'b01: alu = a - b; // Subtraction
                2'b10: alu = a & b; // AND
                2'b11: alu = a | b; // OR
                default: alu = 8'b00000000;
            endcase
        end
    endfunction

    reg [7:0] x, y;
    reg [1:0] opcode;
    wire [7:0] result;

    assign result = alu(x, y, opcode); // using the function

    initial begin
        x = 8'b00001100; // 12
        y = 8'b00000101; // 5

        opcode = 2'b00; #10;
        $display("Addition Result: %d", result); // 12 + 5 = 17

        opcode = 2'b01; #10;
        $display("Subtraction Result: %d", result); // 12 - 5 = 7

        opcode = 2'b10; #10;
        $display("AND Result: %b", result); // AND operation

        opcode = 2'b11; #10;
        $display("OR Result: %b", result); // OR operation
    end
endmodule

Summary

✅ Functions can be effectively used in combinational circuits such as decoders and ALUs ✅ Using case statements allows flexible operation descriptions ✅ Functions improve readability and make the design more reusable ✅ Functions are best suited for combinational logic, but not for sequential circuits (since they cannot include delays)

5. Important Considerations When Using Verilog Functions

Verilog functions are powerful tools that improve code readability and reusability, but they also have certain restrictions. In this section, we’ll explain the key points you need to be aware of when using functions.

Recursive Calls Are Not Allowed

In Verilog functions, recursive calls are prohibited. This means a function cannot call itself inside its own body.

❌ NG Example: Recursive Function

function [3:0] factorial;
    input [3:0] n;
    begin
        if (n == 0)
            factorial = 1;
        else
            factorial = n * factorial(n - 1); // ❌ Recursive call not allowed
    end
endfunction
This code will result in a simulation error.

✅ Solution: Use Loops Instead

If recursion is needed, use a loop inside an always block or a task instead.
task factorial_task;
    input [3:0] n;
    output [15:0] result;
    integer i;
    begin
        result = 1;
        for (i = 1; i <= n; i = i + 1)
            result = result * i;
    end
endtask
By using loops, recursion can be avoided.

Time Delays (#10) Cannot Be Used Inside Functions

Since Verilog functions are evaluated immediately (work as combinational logic), they cannot include time delays such as #10.

❌ NG Example: Delay Inside a Function

function [7:0] delay_function;
    input [7:0] in;
    begin
        #10; // ❌ Delay not allowed inside functions
        delay_function = in + 1;
    end
endfunction
This code will cause a compilation error.

✅ Solution: Use Always Blocks Instead

If delays are required, use an always block or a task instead of a function.
task delay_task;
    input [7:0] in;
    output [7:0] out;
    begin
        #10;
        out = in + 1;
    end
endtask
In short, use tasks for operations that involve delays.

Choosing Between Functions and Tasks

In Verilog, both functions and tasks exist. While they look similar, they have different use cases and must be chosen appropriately.
ItemFunctionTask
OutputOnly one (returned via function name)Multiple allowed (via output variables)
Inputinput onlyinput / output both allowed
Local VariablesAllowedAllowed
Delay (#10)Not allowedAllowed
Usage inside alwaysAllowedNot allowed
Invocationfunction_name(arguments)task_name(arguments);

When to Use a Function

✅ When you need an immediate calculation result (e.g., addition, subtraction, logic operations) ✅ For describing combinational logic without delays ✅ When only a single return value is required

When to Use a Task

✅ When delays (#10, etc.) are required ✅ When multiple outputs are needed ✅ For simulation/debug operations (monitoring, display, etc.)

Functions Cannot Be Defined Inside Always Blocks

Verilog functions cannot be defined inside an always block. Functions must be defined outside and then called within always.

❌ NG Example: Defining a Function Inside Always

always @(a or b) begin
    function [7:0] my_function; // ❌ Not allowed inside always
        input [7:0] x, y;
        begin
            my_function = x + y;
        end
    endfunction
end
This code will result in a compilation error.

✅ Correct Example

Define the function outside of always and call it inside:
function [7:0] add_function;
    input [7:0] x, y;
    begin
        add_function = x + y;
    end
endfunction

always @(a or b) begin
    result = add_function(a, b); // ✅ call the function
end

Summary

✅ Verilog functions have several restrictions ✅ No recursive calls (use loops or tasks instead) ✅ No delays (#10) (use always or tasks instead) ✅ Cannot be defined inside always blocks (must be defined outside) ✅ Only one return value (use tasks if multiple outputs are needed) ✅ Use functions and tasks appropriately based on the situation

6. [FAQ] Frequently Asked Questions About Verilog Functions

So far, we have covered the basics, advanced usage, and important considerations of Verilog functions. In this section, we summarize frequently asked questions and answers about Verilog functions.

What is the difference between a function and a task?

Q. What is the difference between a Verilog function and a task? Which one should I use?

A. A function is used when you need to “return a single value immediately,” while a task is used when you need “multiple outputs or operations that involve delays.”

ItemFunctionTask
OutputOnly one (returned via function name)Multiple allowed (via output variables)
Inputinput onlyinput / output both allowed
Local VariablesAllowedAllowed
Delay (#10)Not allowedAllowed
Usage inside alwaysAllowedNot allowed
Invocationfunction_name(arguments)task_name(arguments);

When to Use a Function

✅ When you need an immediate calculation result (e.g., addition, subtraction, logical operations) ✅ For describing combinational logic without delays ✅ When only one return value is needed

When to Use a Task

✅ When you need delays (e.g., #10) ✅ When multiple outputs are required ✅ When writing debug/monitoring code for simulation

Can I use reg inside a function?

Q. Can I declare reg variables inside a function?

A. No, you cannot use reg inside a function, but you can use integer instead.

In Verilog functions, you cannot declare variables of type reg, but you can use integer for calculations.

✅ Correct Example (Using integer)

function [7:0] multiply;
    input [3:0] a, b;
    integer temp;
    begin
        temp = a * b;
        multiply = temp;
    end
endfunction

When should I use functions?

Q. In which situations is it appropriate to use functions?

A. Functions are best suited for “simple arithmetic operations” and “combinational logic.”

Examples where functions are useful include:
  • Arithmetic operations (addition, subtraction, logic)
  • Decoders and encoders
  • Comparisons (finding maximum/minimum values)
  • Error checking (e.g., parity check)
However, functions are not suitable for sequential circuits that include flip-flops.

Can one function call another function?

Q. Can a Verilog function call another function inside it?

A. Yes, a function can call another function, but be careful with dependencies.

function [7:0] add;
    input [7:0] a, b;
    begin
        add = a + b;
    end
endfunction

function [7:0] double_add;
    input [7:0] x, y;
    begin
        double_add = add(x, y) * 2; // calling another function
    end
endfunction

How should I choose between functions and always blocks?

Q. How should I decide whether to use a function or an always block?

A. Functions are used for “combinational logic,” while always blocks are used for “sequential logic.”

ItemFunctionAlways Block
Delay (#10)Not allowedAllowed
State RetentionNot allowed (immediate evaluation only)Allowed (can act as flip-flops)
Main UseCombinational logic (instant calculations)Sequential logic (flip-flops, counters)
For example, when performing addition:

✅ Function (Combinational Logic)

function [7:0] add;
    input [7:0] a, b;
    begin
        add = a + b;
    end
endfunction

✅ Always Block (Sequential Logic)

always @(posedge clk) begin
    sum <= a + b; // works as a flip-flop
end

Summary

✅ Functions are best for simple operations and combinational logic ✅ Understand the differences between functions and tasks and use them appropriately ✅ Always blocks are for sequential logic, functions are for combinational logic ✅ Functions cannot include delays (#10) or arrays — use tasks or modules instead