Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Closed 6 months ago.
Improve this question
#define BUFC 1024
enum {NSTD = 64, NMARK = 100};
typedef struct student{
int sid;
int nmarks; /* number grades */
int marks[NMARK]; /* grades array */
} student;
int cmpid(const void *a, const void *b );
int main(int argc, char **argv){
char buf[BUFC];
int i,j, sidx = 0;
student s[NSTD] = {{.sid = 0,.marks = 0 }};
FILE *fp = argc > 1 ? fopen(argv[1],"r") : stdin;
if(!fp){
fprintf(stderr,"error: file open failed '%s'.\n", argv[1]);
return 1;
}
printf("\nEnter student ID followed by grad (0,100)"
" 101 for next student, 102 when finished.\n");
for(; sidx < NSTD;){
int grade = 0, tries = 0;
int n;
int offset;
// printf(" enter student ID, grade for student");
if(!fgets(buf,BUFC,stdin)){
fputs("\n(user canceled input)\n",stdout);
break;
}
buf[strcspn(buf,"\n")] = 0;
char *data = buf;
while (sscanf(data," %d%n",&n,&offset) == 1)
{
s[sidx].marks[s[sidx].nmarks++] = n;
data = data + offset;
}
sidx ++;
}
if(fp != stdin) fclose(fp);
for(i = 0; i < sidx; i++){
s[i].sid = s[i].marks[0];
}
printf("sidx=%d\n",sidx);
for(i = 0; i < 2; i++){
printf("\nStudent ID:%3d\tgrades:",s[i].sid);
// printf("nmarks=%d\n",s[i].nmarks);
// for(j = 0; j<s[i].nmarks-1; j++)
// printf("\t%2d",s[i].marks[j+1]);
}
putchar('\n');
printf("Before Qsort: s[0].sid=%d\n",s[0].sid);
qsort(s,sidx, sizeof *s,cmpid);
printf("After Qsort s[0].sid=%d\n",s[0].sid);
return 0;
}
int cmpid(const void *a, const void *b )
{
const struct student* s1 = (student *) a;
const struct student* s2 = (student *) b;
return (s1->sid > s2->sid) - (s1->sid > s2->sid);
}
Run/Build it via gcc array_struct20.c && ./a.out <dat/idmarks.txt stdout as
Enter student ID followed by grad (0,100) 101 for next student, 102 when finished.
(user canceled input)
sidx=10
Student ID:667 grades:
Student ID:166 grades:
Before Qsort: s[0].sid=667
After Qsort s[0].sid=667
Context: Need help changing Structure of Array to Array of Structures
Before and after qsort s[0].sid would be different. So how to make qsort working.
(s1->sid > s2->sid) - (s1->sid > s2->sid)
s1->sid > s2->sid will be 0 or 1 so you'll have either 0 - 0 or 1 - 1. The result is always 0 (meaning that they will all compare equal).
If you want them sorted in ascending order:
int cmpid(const void* a, const void* b) {
const struct student* s1 = a;
const struct student* s2 = b;
if(s1->sid < s2->sid) return -1;
if(s1->sid > s2->sid) return 1;
return 0;
}
Possible x86-64 assembly:
gcc clang
mov eax, DWORD PTR [rsi] mov eax, dword ptr [rdi]
cmp DWORD PTR [rdi], eax xor ecx, ecx
mov edx, -1 cmp eax, dword ptr [rsi]
setg al setg cl
movzx eax, al mov eax, -1
cmovl eax, edx cmovge eax, ecx
ret ret
You could also use the clever construct:
return (s1->sid > s2->sid) - (s1->sid < s2->sid);
In that case you may get this assembly:
gcc clang
mov eax, DWORD PTR [rsi] mov ecx, dword ptr [rdi]
cmp DWORD PTR [rdi], eax xor eax, eax
setg al xor edx, edx
setl dl cmp ecx, dword ptr [rsi]
movzx edx, dl setg al
movzx eax, al setl dl
sub eax, edx sub eax, edx
ret ret
Demo
How would I go about designating a portion of my assembly code as a function and calling that function from within the _asm {} block? Let's say for example, I wanted the function to start at the for loop, "n" elements are filled with a value.
#include <stdio.h>
#include <string.h>
void printBytes(char *data, int length)
{
int x;
for (x = 0; x < length; x++)
{
if ((x & 0xF) == 0) printf("\n");
printf("%02X ", (unsigned char)data[x]);
}
printf("\n\n");
return;
} // printBytes
void function(){
char string[] = "The end is near!";
void* dst = &string;
unsigned char value = 0xA5;
int nCount = 5;
printf("The message is: %s\n", string);
printBytes(string, strlen(string));
__asm {
//type cast the str from void* to char*
mov eax, DWORD PTR [dst]
mov DWORD PTR [ebp-88], eax
//fill "n" elements/blocks with value
mov DWORD PTR [ebp-76], 0
jmp label_3
label_2:
mov eax, DWORD PTR[ebp-76]
add eax, 1
mov DWORD PTR [ebp-76], eax
label_3:
mov eax, DWORD PTR [ebp-76]
cmp eax, DWORD PTR [nCount]
jge EXIT
mov eax, DWORD PTR [ebp-88]
add eax, DWORD PTR [ebp-76]
mov cl, BYTE PTR [value]
mov BYTE PTR[eax], cl
jmp label_2
EXIT:
}// asm_memset */
printf("Now the message is: %s\n", string);
printBytes(string, strlen(string));
return;
}
int main() {
function();
printf("Press ENTER key to continue...");
getchar();
return(0);
}
Please note the solution to your problem is likely to be non-portable.
You will need to find the ABI for your architecture/system/compiler, and comply with its calling conventions.
I am having trouble figuring out how to use the buffer in my code. The code is supposed to loop through and count the number of each char is in the array. I haven't written the function for lower case and upper case chars yet but for the int part it outputs "0 - +0" every time no matter what combination of integers or letters I input. I'm not sure if this issue has to do with the buffer or if its from another part of my code. Any suggestions, tips, or explanations are welcome. I am compiling on Visual Studios 2015 with the kip irvine library.
.data
buffer BYTE 1064 DUP(?)
;sentence input
sentence dword ?
;enter gallons prompt
prompt1 BYTE "Enter the sentence you would like to count: ", 0
;start of int values
intEnd dword 57
;int you are on
intIndex dword 48
;upper char you are on
upcharIndex dword 65
;start of upper case char values
upcharEnd dword 90
;lower char you are on
lowCharIndex dword 97
;start of lower case char values
lowcharEnd dword 122
;prompt dash
dash BYTE " - "
;count vals
count dword 0
.code
main PROC
;shows the prompt
mov edx, OFFSET prompt1
call WriteString
mov edx, OFFSET buffer
mov ecx, SIZEOF buffer
;reads the sentence the user inputs
call ReadString
mov sentence, eax
mov ebx, OFFSET sentence
mov ecx, [LENGTHOF sentence]
checkint:
mov eax, intIndex
cmp eax, intEnd
je done
mov edx, count
L1:
call DumpRegs
cmp al, [ebx]
jne no_inc
cmp al, 00
je none
incre:
inc dl
no_inc:
add ebx, 8
jmp L1
none:
mov intIndex, eax
call WriteChar
call DumpRegs
mov count, edx
mov edx, OFFSET dash
call WriteString
call DumpRegs
mov eax, count
call WriteInt
mov eax,intIndex
inc eax
mov intIndex, eax
call DumpRegs
mov count, eax
jmp checkint
done:
RET
exit
main ENDP
END main
C++ code:
#include<iostream>
#include<string>
using namespace std;
int main()
{
int startint = 48;
int endint = 57;
int startupper = 65;
int endupper = 90;
int startlower = 97;
int endlower = 122;
int count = 0;
cout << "Enter the string you would like to count: ";
string sentence;
getline(cin, sentence);
cout << endl;
for (int i = startint; i < endint; i++)
{
for (char a : sentence)
{
if (a == i)
count++;
}
if(count !=0)
cout << (char)i << " - " << count<<endl;
count = 0;
}
for (int i = startupper; i < endupper; i++)
{
for (char a : sentence)
{
if (a == i)
count++;
}
if(count !=0)
cout << (char)i << " - " << count<<endl;
count = 0;
}
for (int i = startlower; i < endlower; i++)
{
for (char a : sentence)
{
if (a == i)
count++;
}
if(count !=0)
cout << (char)i << " - " << count<<endl;
count = 0;
}
return 0;
}
call ReadString
mov sentence, eax
mov ebx, OFFSET sentence
mov ecx, [LENGTHOF sentence]
The ReadString function returns the size of the input in the EAX register. Yet you use this as an address!
call ReadString
mov sentence, eax ;This is a length !
mov ebx, OFFSET buffer
mov ecx, sentence
cmp al, [ebx]
jne no_inc
cmp al, 00
je none
Check for the end of the string before doing anything else:
cmp byte ptr [ebx], 0
je none
cmp al, [ebx]
jne no_inc
Since count is a dword, increment EDX rather than DL.
Since strings use 1 byte per character, add just 1 to EBX in stead of 8.
checkint:
mov eax, intIndex
cmp eax, intEnd
je done
This way you'll miss the final iteration! Only jump to done when EAX is above intEnd:
checkint:
mov eax, intIndex
cmp eax, intEnd
ja done
I hope this helps to get the main code working...
How do I convert a string of number (decimals) to a integer (binary) using IA-32 assembler in c++?
Here is a shell of what I need.
#include <stdio.h>
int main(int argc, char** argv) {
int iOut = 0;
char* pcInp;
if (argc < 2) {
printf("Mssing parameter: number\n");
return(0);
}
pcInp = argv[1];
_asm {
push aex
push ebx
push ecx
push edx
//code here
pop edx
pop ecx
pop ebx
pop eax
}
printf("Number was processed as %d\n", iOut);
}
Solved, maybe someone else will need this.
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
int main(int argc, char** argv)
{
int Lenght;
int pirmasSkaicius = 0;
int antrasSkaicius = 0;
int treciasSkaicius = 0;
int ketvirtasSkaicius = 0;
int rez = 0;
char * numbEntered = new char[10];
if (argc < 2) {
printf("No parameter: number\n");
return(0);
}
numbEntered = argv[1];
Lenght = strlen(numbEntered);
cout << "Lenght: " << Lenght << endl;
__asm {
push eax
push ebx
push ecx
push edx
add treciasSkaicius, eax
add ketvirtasSkaicius, edx
xor eax, eax
xor edx, edx
mov ecx, numbEntered
mov al, byte ptr[ecx]
sub eax, 48
mov ebx, 1000
imul eax, ebx
mov pirmasSkaicius, eax
inc ecx
xor eax, eax
xor edx, edx
mov al, byte ptr[ecx]
sub eax, 48
mov ebx, 100
imul eax, ebx
mov antrasSkaicius, eax
xor eax, eax
xor edx, edx
inc ecx
mov al, byte ptr[ecx]
sub eax, 48
mov ebx, 10
imul eax, ebx
mov treciasSkaicius, eax
inc ecx
xor eax, eax
xor edx, edx
mov al, byte ptr[ecx]
sub eax, 48
mov ketvirtasSkaicius, eax
add edx, pirmasSkaicius
add edx, antrasSkaicius
add edx, treciasSkaicius
add edx, ketvirtasSkaicius
mov rez, edx
pop edx
pop ecx
pop ebx
pop eax
}
cout << "Processed: " << rez << endl;
cout << "Pieces as: " << pirmasSkaicius << " " << antrasSkaicius << " " << treciasSkaicius << " " << ketvirtasSkaicius << endl;
system("pause");
return 0;
}
EDIT partial solution below (EDIT 2), but I have still one question (see at the end)
I am trying to compile the following C program with gcc-4.9.2, on Windows 7, 32 bits, running on a Pentium G3220 (according to Windows System Information). If I understand correctly, this processor does not have AVX extensions, so it's quite natural that something happens, I am just unsure about what exactly. Initially, I was playing with optimizations with gcc, and I tried -mavx rather "accidentally".
The following program computes permutations of numbers 0 ... n-1 (with n given as an argument) in lexicographic order, and also rank of each permutation (its position in this sequential order), and "unrank" (recover permutation from rank), and checks that all of these are correct. It should only print "OK" or "Error" in the end.
With gcc -O3, the program runs correctly with all integer input I checked (1 <= n <= 11).
With gcc -O3 -mavx, it runs correctly for 1 <= n <= 7, and for n >= 8, it prints nothing, and actually it does nothing (almost no delay before exiting). I get no message from the program or from Windows (I would have expected maybe a crash with an unknown instruction, but it didn't happen).
(On another computer with Windows 7 64 bits, on a core-i5, and the same gcc-4.9.2, the program seems to run fine with of without -mavx, when compiled either in 32 or 64 bits)
What I don't understand is why it runs correctly for some input values, and fails for other ones. Does anybody have some hint about this?
Here is the full program, followed by a shorter one with the same problem.
#include <stdlib.h>
#include <stdio.h>
#define SWAP(a,b) {int c; c = a; a = b; b = c;}
int next_perm(int n, int a[n]) {
int i, j, k;
for(i = n - 1; i > 0 && a[i - 1] > a[i]; i--);
for(j = i, k = n - 1; j < k; j++, k--) SWAP(a[j], a[k]);
if(i == 0) return 0;
for(j = i--; a[j] < a[i]; j++);
SWAP(a[i], a[j]);
return 1;
}
#undef SWAP
void copyvec(int n, int dst[n], int src[n]) {
int i;
for(i = 0; i < n; i++) {
dst[i] = src[i];
}
}
int eqvec(int n, int a[n], int b[n]) {
int i;
for(i = 0; i < n; i++) {
if(a[i] != b[i]) return 0;
}
return 1;
}
int rank(int n, int a[n]) {
int v[n], i, j, r;
v[n - 1] = 1;
for(j = n - 2; j >= 0; j--) v[j] = v[j + 1]*(n - 1 - j);
for(r = i = 0; ; i++) {
for(j = i; j < n; j++) {
if(a[j] > j) goto cont;
}
return r;
cont:
i = j;
r += v[i]*(a[i] - i);
for(j = i + 1; j < n; j++) {
if(a[j] < a[i]) a[j]++;
}
}
}
void unrank(int n, int a[n], int p) {
int v[n], i, j, r, s;
v[n - 1] = 1;
for(i = n - 2; i >= 0; i--) v[i] = v[i + 1]*(n - 1 - i);
p %= n*v[0];
for(i = 0; i < n; i++) a[i] = i;
for(i = 0; p > 0; i++) {
for(; v[i] > p; i++);
r = p/v[i];
p %= v[i];
for(s = a[j = i + r]; j >= i; j--) a[j] = a[j - 1];
a[i] = s;
}
}
int main(int argc, char **argv) {
int n, i, r, s = 0, q = 0;
int *a = NULL, *b = NULL, *c = NULL;
if(argc == 2 && (n = strtol(argv[1], NULL, 0)) > 0) {
a = malloc(n*sizeof(int));
b = malloc(n*sizeof(int));
c = malloc(n*sizeof(int));
if(!a || !b || !c) {
puts("Unable to allocate memory");
goto end;
} else {
for(i = 0; i < n; i++) a[i] = i;
do {
copyvec(n, b, a);
r = rank(n, b);
unrank(n, c, r);
q |= s++ != r || !eqvec(n, a, c);
} while(next_perm(n, a));
puts(q?"Error":"OK");
}
} else {
puts("perm n - Check all permutations of {0 ... n - 1}, with n > 0");
}
end:
if(a) free(a);
if(b) free(b);
if(c) free(c);
return 0;
}
EDIT
Following Brian Cain's comment, here is a shorter program with the same problem. I removed all checks on input value, all the rank/unrank stuff, and I replaced the malloc/free with an array of size 20 (only one now, since b and c are not used anymore). Now the program only computes the permutations with the while(next_perm(n, a)); loop, and does nothing with them. It should still print "OK" in the end, though, because the value of q does not change after the initial q=0.
#include <stdlib.h>
#include <stdio.h>
#define SWAP(a,b) {int c; c = a; a = b; b = c;}
int next_perm(int n, int a[n]) {
int i, j, k;
for(i = n - 1; i > 0 && a[i - 1] > a[i]; i--);
for(j = i, k = n - 1; j < k; j++, k--) SWAP(a[j], a[k]);
if(i == 0) return 0;
for(j = i--; a[j] < a[i]; j++);
SWAP(a[i], a[j]);
return 1;
}
#undef SWAP
int main(int argc, char **argv) {
int n, i, r, s = 0, q = 0, a[20];
n = strtol(argv[1], NULL, 0);
for(i = 0; i < n; i++) a[i] = i;
while(next_perm(n, a));
puts(q?"Error":"OK");
return 0;
}
EDIT 2: explanation of the assembly output
I add also the disassembly output of gcc (in Intel syntax), found with gcc -O3 -mavx -S -masm=intel and gcc-4.9.2 (see link above for the actual binary files of the compiler). However, it needs some work, because as is, gcc will inline the call to next_perm, and it's less readable. I also remove the CFI directives and alignment and actually all other directives, to improve readability:
_next_perm:
LFB0:
push ebp
push edi
push esi
push ebx
mov ecx, DWORD PTR [esp+20]
mov edx, DWORD PTR [esp+24]
lea eax, [ecx-1]
test eax, eax
jle L12
mov edi, DWORD PTR [edx-4+ecx*4]
cmp DWORD PTR [edx-8+ecx*4], edi
mov ecx, eax
jg L5
jmp L11
L28:
mov esi, DWORD PTR [edx+ecx*4]
cmp DWORD PTR [edx-4+ecx*4], esi
jle L27
L5:
sub ecx, 1
jne L28
L4:
mov ebx, ecx
L7:
mov esi, DWORD PTR [edx+ebx*4]
mov edi, DWORD PTR [edx+eax*4]
mov DWORD PTR [edx+ebx*4], edi
mov DWORD PTR [edx+eax*4], esi
add ebx, 1
sub eax, 1
cmp ebx, eax
jl L7
L2:
xor eax, eax
test ecx, ecx
je L23
L11:
sal ecx, 2
lea esi, [edx+ecx]
lea ebp, [edx-4+ecx]
mov ebx, DWORD PTR [esi]
mov edi, DWORD PTR [ebp+0]
cmp edi, ebx
jle L9
lea eax, [edx+4+ecx]
L10:
mov esi, eax
add eax, 4
mov ebx, DWORD PTR [eax-4]
cmp ebx, edi
jl L10
L9:
mov DWORD PTR [ebp+0], ebx
mov eax, 1
mov DWORD PTR [esi], edi
L23:
pop ebx
pop esi
pop edi
pop ebp
ret
L27:
cmp eax, ecx
jg L4
jmp L11
L12:
mov ecx, eax
jmp L2
The assembly output is the same with or without -mavx, apart from label numbers: there is no AVX instruction, which means the problem actually lies in main.
This can be checked by adding some puts in main:
int main(int argc, char **argv) {
int n, i, q = 0, a[20];
puts("X");
n = strtol(argv[1], NULL, 0);
puts("Y");
for(i = 0; i < n; i++) a[i] = i;
puts("Z");
while(next_perm(n, a));
puts(q?"Error":"OK");
return 0;
}
Then, the programs prints only X and Y when it fails, hence the problem comes from the AVX instructions used to build 'a' in the for loop between Y and Z.
Here is the assembly output of main, again without directives (LC2 points to "Y", and LC3 to "Z"). The only AVX instructions in the assembly ouptut of main are between those two puts, and they are used for the for loop that builds the initial 'a', that is the array {0, 1, ..., n-1}. What happens actually, is that AVX instructions are used to build several elements of 'a' at a time (4 I guess), and if the length of 'a' is not a multiple of 4, then there is an additional step (between L4 and L9), before calling the puts("Z") at L9, then the while(next_perm(n, a)); at L3. Thus, the problem is very simple: if n is small enough, then the AVX loop is actually not run, and there is no error. Here the maximum valid n is 4, but it varies between differents runs of gcc, it's a bit randomized it seems (I got 8 yesterday).
The LC0 and LC4 labels point to two arrays of 4 elements that are used by the AVX instructions: LC0 is {0,1,2,3}, and LC4 is {4,4,4,4}. No wonder why they are here, even without deep knowledge of AVX, it smells like an unrolled loop :-)
_main:
push ebp
mov ebp, esp
push edi
push esi
push ebx
and esp, -16
sub esp, 96
call ___main
mov DWORD PTR [esp], OFFSET FLAT:LC1
call _puts
mov eax, DWORD PTR [ebp+12]
mov DWORD PTR [esp+8], 0
mov DWORD PTR [esp+4], 0
mov eax, DWORD PTR [eax+4]
mov DWORD PTR [esp], eax
call _strtol
mov DWORD PTR [esp], OFFSET FLAT:LC2
mov ebx, eax
call _puts
test ebx, ebx
jle L17
lea edx, [ebx-4]
lea ecx, [ebx-1]
shr edx, 2
add edx, 1
cmp ecx, 3
lea eax, [0+edx*4]
jbe L10
vmovdqa xmm1, XMMWORD PTR LC4
lea esi, [esp+16]
xor ecx, ecx
vmovdqa xmm0, XMMWORD PTR LC0
L5:
mov edi, ecx
add ecx, 1
sal edi, 4
cmp edx, ecx
vmovaps XMMWORD PTR [esi+edi], xmm0
vpaddd xmm0, xmm0, xmm1
ja L5
cmp ebx, eax
je L9
L4:
lea edx, [eax+1]
mov DWORD PTR [esp+16+eax*4], eax
cmp ebx, edx
jle L9
mov DWORD PTR [esp+16+edx*4], edx
lea edx, [eax+2]
cmp ebx, edx
jle L9
add eax, 3
mov DWORD PTR [esp+16+edx*4], edx
cmp ebx, eax
jle L9
mov DWORD PTR [esp+16+eax*4], eax
L9:
mov DWORD PTR [esp], OFFSET FLAT:LC3
call _puts
L3:
mov DWORD PTR [esp+4], esi
mov DWORD PTR [esp], ebx
call _next_perm
test eax, eax
jne L3
mov DWORD PTR [esp], OFFSET FLAT:LC5
call _puts
lea esp, [ebp-12]
xor eax, eax
pop ebx
pop esi
pop edi
pop ebp
ret
L10:
xor eax, eax
lea esi, [esp+16]
jmp L4
L17:
lea esi, [esp+16]
jmp L9
Now, I understand what actually happens, but one question remains: why is there no error message whatsoever when the program tries to run an AVX instruction? It simply exits, or it's killed, but without any hint that something went wrong.
This code always results in:
where parameter = n
a[] = {0,0,2, 3, ...,n-2,n-1}
b[] = {n-1, n-1, ... , n-1}
c[] = {n-1, n-2, ... , 0}
when it reaches the above conditions,
then it exits with "OK"
the amount of time spent executing the code
climbs at an exponential rate
as the value of the parameter is increased