CODEWITHSUNDEEP
cmalloc
Mark E
Mark E

Reputation: 3483

two mallocs returning same pointer value

I'm filling a structure with data from a line, the line format could be 3 different forms:
1.-"LD "(Just one word)
2.-"LD A "(Just 2 words)
3.- "LD A,B "(The second word separated by a coma).
The structure called instruccion has only the 3 pointers to point each part (mnemo, op1 and op2), but when allocating memory for the second word sometimes malloc returns the same value that was given for the first word. Here is the code with the mallocs pointed:

instruccion sepInst(char *linea){
instruccion nueva;
char *et;

while(linea[strlen(linea)-1]==32||linea[strlen(linea)-1]==9)//Eliminating spaces and tabs at the end of the line
    linea[strlen(linea)-1]=0;
et=nextET(linea);//Save the direction of the next space or tab
if(*et==0){//If there is not, i save all in mnemo
    nueva.mnemo=malloc(strlen(linea)+1);
    strcpy(nueva.mnemo,linea);
    nueva.op1=malloc(2);
    nueva.op1[0]='k';nueva.op1[1]=0;//And set a "K" for op1
    nueva.op2=NULL;
    return nueva;
}
nueva.mnemo=malloc(et-linea+1);<-----------------------------------
strncpy(nueva.mnemo,linea,et-linea);
nueva.mnemo[et-linea]=0;printf("\nj%xj",nueva.mnemo);
linea=et;
while(*linea==9||*linea==32)//Move pointer to the second word
    linea++;
if(strchr(linea,',')==NULL){//Check if there is a coma
    nueva.op1=malloc(strlen(linea)+1);//Do this if there wasn't any coma
    strcpy(nueva.op1,linea);
    nueva.op2=NULL;
}
else{//Do this if there was a coma
    nueva.op1=malloc(strchr(linea,',')-linea+1);<----------------------------------
    strncpy(nueva.op1,linea,strchr(linea,',')-linea);
    nueva.op1[strchr(linea,',')-linea]=0;
    linea=strchr(linea,',')+1;
    nueva.op2=malloc(strlen(linea)+1);
    strcpy(nueva.op2,linea);printf("\n2j%xj2",nueva.op2);
}
return nueva;
}

When I print the pointers it happens to be the same number. note: the function char *nextET(char *line) returns the direction of the first space or tab in the line, if there is not it returns the direction of the end of the line.

sepInst() is called several times in a program and only after it has been called several times it starts failing. These mallocs across all my program are giving me such a headache.

Upvotes: 0

Views: 603

Answers (2)

johnnycrash
johnnycrash

Reputation: 5344

On a side note, personally, I think you should work harder to call malloc less. It's a good idea for performance, and it also causes corruption less.

nueva.mnemo=malloc(strlen(linea)+1);
strcpy(nueva.mnemo,linea);
nueva.op1=malloc(2);

should be

// strlen has to traverse your string to get the length,
// so if you need it more than once, save its value.
cbLineA = strlen(linea); 
// malloc for the string, and the 2 bytes you need for op1.
nueva.mnemo=malloc(cbLineA + 3);
// strcpy checks for \0 again, so use memcpy
memcpy(nueva.mnemo, linea, cbLineA);  
nueva.mnemo[cbLineA] = 0;
// here we avoid a second malloc by pointing op1 to the space we left  after linea
nueva.op1 = nueva.mnemo + cbLinea + 1;

Whenever you can reduce the number of mallocs by pre-calculation....do it. You are using C! This is not some higher level language that abuses the heap or does garbage collection!

Upvotes: 0

Jirka Hanika
Jirka Hanika

Reputation: 13529

There are two main possibilities.

Either you are freeing the memory somewhere else in your program (search for calls to free or realloc). In this case the effect that you see is completely benign.

Or, you might be suffering from memory corruption, most likely a buffer overflow. The short term cure is to use a specialized tool (a memory debugger). Pick one that is available on your platform. The tool will require recompilation (relinking) and eventually tell you where exactly is your code stepping beyond previously defined buffer limits. There may be multiple offending code locations. Treat each one as a serious defect.

Once you get tired of this kind of research, learn to use the const qualifier and use it with all variable/parameter declarations where you can do it cleanly. This cannot completely prevent buffer overflows, but it will restrict them to variables intended to be writable buffers (which, for example, those involved in your question apparently are not).

Upvotes: 1

Related Questions