generate_if则是根据模块的参数（必须是常量）作为条件判断，来产生满足条件的电路。相当于判断语句。
 
原语：
 
 generate
      if (<condition>) begin: <label_1>
         <code>;
      end else if (<condition>) begin: <label_2>
         <code>;
      end else begin: <label_3>
         <code>;
      end
   endgenerate
 
使用：
 
module sync_bits #(

  // Number of bits to synchronize
  parameter NUM_OF_BITS = 1,
  // Whether input and output clocks are asynchronous, if 0 the synchronizer will
  // be bypassed and the output signal equals the input signal.
  parameter ASYNC_CLK = 1)(

  input [NUM_OF_BITS-1:0] in_bits,
  input out_resetn,
  input out_clk,
  output [NUM_OF_BITS-1:0] out_bits);

generate 
 if (ASYNC_CLK == 1) begin
     reg [NUM_OF_BITS-1:0] cdc_sync_stage1 = 'h0;
     reg [NUM_OF_BITS-1:0] cdc_sync_stage2 = 'h0;

     always @(posedge out_clk)
        begin
          if (out_resetn == 1'b0) begin
              cdc_sync_stage1 <= 'b0;
              cdc_sync_stage2 <= 'b0;
           end
         else begin
              cdc_sync_stage1 <= in_bits;
              cdc_sync_stage2 <= cdc_sync_stage1;
          end
     end
     assign out_bits = cdc_sync_stage2;
  end 
else begin
   assign out_bits = in_bits;
   end 
endgenerate

endmodule
 

循环生成
 1.generate不放在always块中，而是always块等包含在generate中。
 2.generatefor 的名字放在for的begin后面，不要忘记加：
 3.task不能放在generatefor中，要想实现同样的功能，用子模块
 循环生成的主要目的是简化我们的代码书写，利用循环生成语句我们可以将之前需要写很多条比较相似的语句才能实现的功能用很简短的循环生成语句来代替。基本语法如下：
 
genvar ;
generate
for (=0; < ; =+1)
begin: 

end
endgenerate
 
关于以上语法有四点注意：
 1、循环生成中for语句使用的变量必须用genvar关键字定义，genvar关键字可以写在generate语句外面，也可以写在generate语句里面，只要先于for语句声明即可；
 2、必须给循环段起一个名字。这是一个强制规定，并且也是利用循环生成语句生成多个实例的时候分配名字所必须的；
 3、for语句的内容必须加begin-end，即使只有一条语句也不能省略。这也是一个强制规定，而且给循环起名字也离不开begin关键字；
 4、可以是实例化语句也可以是连续赋值语句。
 关于循环生成，举例如下：
 
module aa(a,b,c,d);
input [3:0] a,b;
output [3:0] c,d;

generate
genvar i;
	for (i=0; i < 4; i=i+1) 
	begin :genExample
		myAnd insAnd (.a(a[i]), .b(b[i]), .c(c[i]));
		assign d[i] = a[i];
	end
endgenerate

endmodule

module  myAnd (a,b,c);
input a,b;
output c;
assign c=a&b;
endmodule
 
注意，利用循环生成语句生成的实例名称不能像数组例化那样用方括号表示，否则会报错。那么，你可能会疑惑上例中实例的名字，其实，上述实例化展开来类似：
 
myAnd genExample(0).insAnd (.a(a[0]), .b(b[0]), .c(c[0]));
 myAnd genExample(1).insAnd (.a(a[1]), .b(b[1]), .c(c[1]));
 myAnd genExample(2).insAnd (.a(a[2]), .b(b[2]), .c(c[2]));
 myAnd genExample(3).insAnd (.a(a[3]), .b(b[3]), .c(c[3]));
 
 这也是为什么循环生成语句必须要有个名字。从上例我们还可以看出，当循环语句用作实例化时，所表述的功能跟数组实例化语句其实是类似的。
 
条件生成
 条件生成的目的是为了左右编译器的行为，类似于C语言中的条件选择宏定义，根据一些初始参数来决定载入哪部分代码来进行编译。Verilog中共提供了两种条件生成语句，一种是generate-if语句，一种是generate-case语句，两者的功能几乎相同，只是书写形式不一样而已，分别介绍如下：
 
generate-if语句
 该语句的语法如下：
 
generate
	if (<condition>) begin: <label_1>
		<code>;
	end else if (<condition>) begin: <label_2>
		<code>;
	end else begin: <label_3>
		<code>;
	end
endgenerate
 
关于该语法有三点注意：
 
1、必须是常量比较，例如一些参数，这样编译器才可以在编译前确定需要使用的代码；
 2、if语句的内容中，begin-end只有在 < code > 有多条语句时才是必须的；
 3、每一个条件分支的名称是可选的，这点不像循环生成语句那么严格。
 
关于generate-if语句，举例如下：
 
module aa(c, d0, d1, d2);
input d0,d1,d2;
output  c;
parameter sel = 1;
generate
	if (sel == 0)
		assign c = d0;
	else if (sel == 1)
		assign c = d1;
	else
		assign c = d2;
endgenerate
endmodule
 
该例子表示编译器会根据参数sel的值，来确定到底是让d0~d2中哪个变量和c连通。但是注意，一旦连通，那么要想更改必须修改参数后重新编译，如果需要动态选择，可以写成如下这样，这样资源上却需要一个多路复用器来实现。generate-if是没有多路器的，是直连的。
 assign c = (sel == 0) ? d0 : (sel == 1) ? d1 : d2;
 
 
 
generate-case语句
 该语句的语法如下：
 
generate
		case (<constant_expression>)
			<value>: begin: <label_1>
				<code>
				end
			<value>: begin: <label_2>
<code>
				end
			……
			default: begin: <label_N>
<code>
end
      		endcase
   	endgenerate
 
关于该语法也有三点注意，和generate-if类似：
 1、<constant_expression>必须是常量比较，例如一些参数，这样编译器才可以在编译前确定需要使用的代码；
 2、case语句的内容中，begin-end只有在< code >有多条语句时才是必须的；
 3、每一个条件分支的名称是可选的，这点不像循环生成语句那么严格。
 
关于generate-case语句，举例如下：
 
wire c, d0, d1, d2;
 parameter sel = 1;
 
generate
 case (sel)
 0 :
 assign c = d0;
 1:
 assign c = d1;
 default:
 assign c = d2;
 endcase
 endgenerate
 该例所描述的功能和generate-if小节的例子是一模一样的。
 原文链接：https://blog.csdn.net/Reborn_Lee/article/details/105068239
 
1always块中if的条件内的量可以是wire，也可以是parameter,integer
 （1）是输入wire型时,那么综合出来会有一个选择器
 
module  QQ(a,b,c,clk);
input a,b,clk;
parameter d=1;
output reg c;
always@(posedge clk)
if(a==1)  c=a+b;
else c=b;
endmodule
 

 (2)是parameter时，会直接综合掉
 
module  QQ(a,b,c,clk);
input a,b,clk;
parameter d=1;
output reg c;
always@(posedge clk)
if(d==0)  c=a+b;
else c=b;
endmodule
 

 2generate if内量不能是wire类型
 （1）是wire时会报错
 
module  QQ(a,b,c,clk);
input a,b,clk;
parameter d=1;
output  c;
generate 
if(a==1) assign c=a+b;
else assign c=c;
endgenerate
endmodule 
 
报错
 Error (10734): Verilog HDL error at QQ.v(7): a is not a constant
 （2）是parameter类型时可以，当然条件选择会直接综合掉
 ps:generate中赋值还得assign或者always，再加上条件选择会综合掉，所以generate的作用只是帮助设计者思维设计这么一个过程，不会在设计电路中有体现
 
module  QQ(a,b,c,clk);
input a,b,clk;
parameter d=1;

output  c;
generate 
if(d==1) assign c=a+b;
else assign c=c;
endgenerate
endmodule 
 

最近在至芯科技的书上看到的，觉得还行吧，给大家分享一下。
 一、为什么学习generate？
 在设计中，很多情况下需要编写很多结构相同但是参数不同的赋值语句或者逻辑语句，如果在参数量很大的的情况下，原本的列举就会显得心有余而力不足。c语言中常用for语句来解决此类问题，verilog则为我们提供了generate语句。
 二、generate的基本概念及语法
 generate语句的最主要功能就是对module、reg、assign、always、task等语句或者模块进行复制。
 generate语句有generate_for、generate_if、generate_case三种语句。
 下面开来看看这三种语句有什么不同？
 1、generate_for语句
 注：（1）、必须使用genvar申明一个正整数变量，用作for循环的判断。（genvar是generate语句中的一种变量类型，用在generate_for中声明正整数变量。）
 （2）、需要复制的语句必须写到begin_end语句里面。就算只有一句！！！！！！
 （3）、begin_end需要有一个类似于模块名的名字。
 
	例1、利用generate_for来复制assign语句
 
module	generate_for(
	input	[7:0]          		 data_in			       ,
	output	[1:0]				 t0					,
	output	[1:0]				 t1					,
	output	[1:0]				 t2					,
	output	[1:0]				 t3										
);

wire		[1:0] 		temp [3:0];	//定义位宽为2，深度为4的temp

genvar	i;								//利用genvar声明正整数变量
generate for(i=0;i<4;i=i+1)		//复制模块
	begin : gfor						//begi_end的名字
		assign temp[i] = data_in[2*i+1:2*i]; 
	end
endgenerate

assign t0 = temp[0];//assign temp[0] = data_in[1:0];
assign t1 = temp[1];//assign temp[1] = data_in[3:2];
assign t2 = temp[2];//assign temp[2] = data_in[5:4];
assign t3 = temp[3];//assign temp[3] = data_in[7:6];

endmodule
 
`timescale  1ns/1ps

module  tb;
reg	[7:0]      		       data_in				;
wire	[1:0]				 t0					;
wire	[1:0]				 t1					;
wire	[1:0]				 t2					;
wire	[1:0]				 t3					;

initial begin
		data_in=8'd0;
		#200;
		data_in = 8'b1100_0011;
		#200;
		data_in = 8'b0011_1100;
		#300;
end

generate_for generate_inst(
	.data_in	(data_in	)			,
	.t0		(t0		)			,
	.t1		(t1		)			,
	.t2		(t2		)			,
	.t3		(t3		)
);

endmodule
 
 
2、generate_if语句
 generate_for用于复制模块，而generate_if则是根据模块的参数（必须是常量）作为条件判断，来产生满足条件的电路。相当于判断语句。
 
例2、
 
module	generate_if(
	input					 t0					,
	input					 t1					,
	input					 t2					,
	output 			        	 d			
);

localparam    S = 6;	            //定义模块所需参数,用于判断产生电路

generate 
	if(S < 7)		
		assign d = t0 | t1 | t2;
	else
		assign d = t0 & t1 & t2;
endgenerate


endmodule
 

 
 由上面我们可以看出模块参数不同，选择的电路就不相同。
 3、generate_case语句
 generate_case其实跟generate_if一样，都是根据参数（都必须为常量）作为判断条件，来产生满足条件的电路，不同于使用了case语法而已。
 例、3
 
module	generate_case(
	input					 t0					,
	input					 t1					,
	input					 t2					,
	output 				        d			
);

localparam    S = 8;	            //定义模块所需参数,用于判断产生电路

generate 
	case(S)
	0:
		assign d = t0 | t1 | t2;
	1:
		assign d = t0 & t1 & t2;
	default:
		assign d = t0 & t1 | t2;
	endcase
endgenerate


endmodule
 
 
 

 由上面3副图其实就可以看出generate_if和generate_case功能其实是一样的。但是比较常用的就是generat_for语句。希望大家能好好学一学，毕竟generate语句还是很有用的噢~
 未完待续！！！！！！！

一：generate

 
Verilog-2001添加了generate循环，允许产生module和primitive的多个实例化，同时也可以产生多个variable，net，task，function，continous assignment，initial和always。在generate语句中可以引入if-else和case语句，根据条件不同产生不同的实例化。

 
用法：

 
1. generate语法有generate for, genreate if和generate case三种

 
2. generate for语句必须有genvar关键字定义for的变量

 
3. for 的内容必须加begin和end

 
4. 必须给for语段起个名字

 
例子：

 
1. generate for例子：

 
generate

 
genvar i; //generate 8 samll fifo for in_data[i] 8X72

 
for(i=0; i<NUM_QUEUES; i=i+1) begin: in_arb_queues //NUM_QUEUES = 8

 
small_fifo

 
#( .WIDTH(DATA_WIDTH+CTRL_WIDTH),

 
.MAX_DEPTH_BITS(2))

 
in_arb_fifo

 
(// Outputs

 
.dout ({fifo_out_ctrl[i], fifo_out_data[i]}),

 
.full (),

 
.nearly_full (nearly_full[i]),

 
.prog_full (),

 
.empty (empty[i]),

 
// Inputs

 
.din ({in_ctrl[i], in_data[i]}),

 
.wr_en (in_wr[i]),

 
.rd_en (rd_en[i]),

 
.reset (reset),

 
.clk (clk));

 
end // block: in_arb_queues

 
endgenerate

 
2.generate if例子：

 
generate

 
if (REG_WIDTH == WRITE_WIDTH) begin : new_data_a_generation

 
assign new_data_a = merge_update ? merge_wr_data : held_wr_data_a;

 
end

 
else begin

 
assign new_data_a = merge_update ?

 
{{(REG_WIDTH - WRITE_WIDTH - 1){merge_wr_data_sign}}, merge_wr_data} :

 
{{(REG_WIDTH - WRITE_WIDTH){held_wr_data_sign_a}}, held_wr_data_a};

 
end

 
endgenerate

 
3.generate还可以进行多个assign赋值！

 
module anytest_v(

 
input clk,

 
input[7:0] datain,

 
output[7:0] dataout,

 
output finish

 
);

 
wire[7:0] mem[31:0];

 
wire[32*8-1:0] xxx;

 
//reg[7:0] i;

 
generate

 
genvar i;

 
for(i=0;i<=31;i=i+1)

 
begin :wiertech

 
assign mem[i]= 8'b0;

 
end

 
endgenerate

 
endmodule

 
ps: 对于a[8*i+:8]

 
this is the so-called "Indexed vector part selects"

 
在Verilog-1995中，可以选择向量的任一位输出，也可以选择向量的连续几位输出，不过此时连续几位的始末数值的index需要是常量。而在Verilog-2001中，可以用变量作为index，进行part select。

 
[base_expr +: width_expr] //positive offset

 
[base_expr -: width_expr] //negative offset

 
其中base_expr可以是变量，而width_expr必须是常量。+：表示由base_expr向上增长width_expr位，-：表示由base_expr向上递减width_expr位。例如：

 
reg [63:0] word;

 
reg [3:0] byte_num; //a value from 0 to 7

 
wire [7:0] byteN = word[byte_num*8 +: 8];

 
如果byte_num的值为4，则word[39:32]赋值给byteN

 
二、参数传递

 
类似VHDL的Generic语句，Verilog也可以在例化时传递参数

 
传递的参数是子模块中定义的parameter。

 
传递的方法：

 
1、module_name #( parameter1, parameter2) inst_name( port_map);

 
2、module_name #( .parameter_name(para_value), .parameter_name(para_value)) inst_name (port map);

 
用#方法和port map的写法差不多

 
module multiplier (a, b, product);

 
parameter a_width = 8, b_width = 8;

 
localparam product_width = a_width+b_width;

 
input [a_width-1:0] a;

 
input [b_width-1:0] b;

 
output[product_width-1:0]product;

 
generate

 
if((a_width < 8) || (b_width < 8))

 
CLA_multiplier #(a_width, b_width) u1 (a, b, product);

 
else

 
WALLACE_multiplier #(a_width, b_width) u1 (a, b, product);

 
endgenerate

 
endmodule