C语言中变量声明的排列方式确定执行哪一个？

Question

Need serious help - I am encountering a very weird problem.

My program is a program that defines different structures in a library file Test.h . This is the Test.h file:

typedef struct InstructionFields{ 
  unsigned int op;         /* opcode: bits 31-26 */
  unsigned int rs;         /* first register source operand: bits 25-21 */
  unsigned int rt;         /* second register source operand: bits 20-16 */
  unsigned int rd;          /* destination register: bits 15-11 */
  unsigned int shamt;      /* shift amount: bits 10-6 */
  unsigned int immedOrAddress;      /* constant or address: bits 15-0 */ 
  unsigned int target;    /* jump target: bits 25-0 */
  unsigned int funct;      /* function: bits 5-0 */
} IF, *IF_ptr;

typedef struct ControlSignalsList{ 
  unsigned int RegDst;         /* Register Destination */
  unsigned int RegWrite;         /* Write Register */
  unsigned int ALUSrc;         /* ALU Source */
  unsigned int MemRead;      /* Mem Read */
  unsigned int MemWrite;      /* Mem Write */ 
  unsigned int MemtoReg;      /* Memory to Register*/
  unsigned int ALUControl ;    /*4 bit ALU control */
  unsigned int Branch;         /* BEQ */
  unsigned int Jump;          /* Jump*/
} CS, *CS_ptr;

typedef struct RegisterStructure{ 
  int t0;         /* Register t0 */
  int t1;         /* Register t1 */
  int t2;         /* Register t2 */
  int t3;         /* Register t0 */
  int ReadData1;      /* Read Data 1 buffer */
  int ReadData2;      /* Read Data 2 buffer */ 
  int WriteReg; 
  unsigned int readReg1;   /* address of rs */
  unsigned int readReg2;   /* address of rt */
   /* WriteReg */
} RG, *RG_ptr;

typedef struct ALUStructure{
  int DataOut;
  unsigned int Zero;
} AS, *AS_ptr;

Next, a file Test.c includes this library, declares variables that use these structures, and then assigns values to different fields of the structure.

This is the Test.c file:

#include "Test.h"
#include <stdio.h>

int main() {
 CS_ptr controlSignals;         // Line 5
 IF_ptr iFields;                // Line 6
 RG_ptr registers;              // Line 7 
 AS_ptr as;                     // Line 8

 controlSignals->RegDst = 0;    // Line 11
 //registers->t0 = 0;           // Line 12
 //iFields->op = 0;             // Line 13
 //as->DataOut = 0;             // Line 14

 printf("This is fine\n");
return 0;
}

The code above is working fine. But as soon as I uncomment line 12, a segmentation fault occurs: Segmentation fault: 11 . I used valgrind and this is the error message:

==2002== Use of uninitialised value of size 8
==2002==    at 0x100000F5A: main (test.c:11)
==2002== 
==2002== Use of uninitialised value of size 8
==2002==    at 0x100000F64: main (test.c:12)
==2002== 
==2002== Invalid write of size 4
==2002==    at 0x100000F64: main (test.c:12)
==2002==  Address 0x0 is not stack'd, malloc'd or (recently) free'd

==2002== Process terminating with default action of signal 11 (SIGSEGV)
==2002==  Access not within mapped region at address 0x0
==2002==    at 0x100000F64: main (test.c:12)
==2002==  If you believe this happened as a result of a stack
==2002==  overflow in your program's main thread (unlikely but
==2002==  possible), you can try to increase the size of the
==2002==  main thread stack using the --main-stacksize= flag.
==2002==  The main thread stack size used in this run was 8388608.

At first I thought it was a problem of unitialized pointers, so I initialized the pointers to NULL . But it didn't fix anything, and even created more segmentation faults. So I left them alone.

Then, I tried moving things around. Weirdly, if I move Line 7 to the top before Line 5 (to declare RG_ptr first), and uncomment Line 11, then registers->t0 = 0 gets executed and the segmentation fault is fixed!

The same thing happens to the other pointer declarations. Only when a pointer declaration is at the beginning does the corresponding field assignment get executed. Any other field assignments, when uncommented, cause segmentation faults.

What is going on? How can this problem be fixed? I appreciate any help!

Answer 1

The problematic code is:

RG_ptr registers;
registers->t0 = 0;

Note that RG_ptr is a pointer and it's never initialized. Using an uninitialized pointer is undefined behaviour and your program crashes.

A NULL pointer is not actually "initialized". That just makes a null pointer, and that's pointing at invalid memory. You can't dereference that pointer without crashes either. Normally people use null pointers to indicate something that's "not assigned" or "not relevant" as opposed to being uninitialized which means the pointer can contain garbage data.

You must initialize that pointer by allocating memory, or pointing it an existing RG structure.

For example:

RG registers;
RG_ptr registers_pointer = &registers;

Or:

RG_ptr registers = malloc(sizeof(RG));

Remember that if you're using allocated memory you need to be extremely disciplined about ensuring all allocations have corresponding deallocations with free or you will leak memory.

Answer 2

You have not allocated space for the structures. And when dereference uninitialized pointer you get segfault which is expectable.

BTW newer typedef pointers.

RG *registers; RG_ptr registers;

The second declaration does not look like pointer. It is a potential source of the hard to spot errors. Use stars for the pointers.