C / C++ / MFC

jschell wrote:

Just curious - what exactly do you think the scope is when a CPU register is used

trønderen wrote:

they were too huge for me to read every word - and in particular: to understand every word of it

Randor wrote:

It reminds me of this old blog post: This processor has no stack

trønderen wrote:

Slight sidetrack

trønderen wrote:

the C/C++ scoping/life time rules apply to the source code only and how it 'conceptually' is executed, and does not relate to the compiled code and how it actually runs.

k5054 wrote:

To add to what jschell said about the spec

Calin Negru wrote:

the program will allocate memory for an int every frame.

Dave Kreskowiak wrote:

It is possible to allocate a value type on the heap, generally called "boxing".

int test(int x, int y)
{
    x = x / y;
    return y << x;
}

 0   x$ = 8
 1   y$ = 16
 2   int test(int,int) PROC                           ; test
 3           mov     r8d, edx
 4           mov     eax, ecx
 5           cdq
 6           idiv    r8d
 7           mov     ecx, eax
 8           shl     r8d, cl
 9           mov     eax, r8d
10           ret     0
11   int test(int,int) ENDP                           ; test

#include <stddef.h>

int test(size_t N, int *data)
{
    int sum = 0;
    for (size_t i = 0; i < N; i++)
        sum += data[i];
    return sum;
}

N$ = 8
data$ = 16
int test(unsigned __int64,int * __ptr64) PROC                       ; test
        xor     r8d, r8d
        mov     r11, rcx
        mov     r10d, r8d
        mov     eax, r8d
        cmp     rcx, 8
        jb      SHORT $LN9@test
        xorps   xmm2, xmm2
        and     rcx, -8
        movdqa  xmm1, xmm2
        npad    3
$LL4@test:
        movdqu  xmm0, XMMWORD PTR [rdx+rax*4]
        paddd   xmm0, xmm2
        movdqa  xmm2, xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+rax*4+16]
        add     rax, 8
        paddd   xmm0, xmm1
        movdqa  xmm1, xmm0
        cmp     rax, rcx
        jb      SHORT $LL4@test
        paddd   xmm1, xmm2
        movdqa  xmm0, xmm1
        psrldq  xmm0, 8
        paddd   xmm1, xmm0
        movdqa  xmm0, xmm1
        psrldq  xmm0, 4
        paddd   xmm1, xmm0
        movd    r10d, xmm1
$LN9@test:
        mov     r9d, r8d
        cmp     rax, r11
        jae     SHORT $LN20@test
        mov     rcx, r11
        sub     rcx, rax
        cmp     rcx, 2
        jb      SHORT $LC14@test
        lea     rcx, QWORD PTR [r11-1]
        npad    1
$LL16@test:
        add     r8d, DWORD PTR [rdx+rax*4]
        add     r9d, DWORD PTR [rdx+rax*4+4]
        add     rax, 2
        cmp     rax, rcx
        jb      SHORT $LL16@test
$LC14@test:
        cmp     rax, r11
        jae     SHORT $LN15@test
        add     r10d, DWORD PTR [rdx+rax*4]
$LN15@test:
        lea     eax, DWORD PTR [r9+r8]
        add     eax, r10d
        ret     0
$LN20@test:
        mov     eax, r10d
        ret     0
int test(unsigned __int64,int * __ptr64) ENDP                       ; test

BOOL IsRunAsAdministrator()
{
    BOOL isRunAsAdmin = FALSE;
    DWORD dwError = ERROR_SUCCESS;
    PSID pAdministratorsGroup = NULL;

    // Allocate and initialize a SID of the administrators group.
    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
    if (!AllocateAndInitializeSid(
        &NtAuthority, 
        2, 
        SECURITY_BUILTIN_DOMAIN_RID, 
        DOMAIN_ALIAS_RID_ADMINS, 
        0, 0, 0, 0, 0, 0, 
        &pAdministratorsGroup))
    {
        goto Cleanup;
    }

    // Determine whether the SID of administrators group is enabled in 
    // the primary access token of the process.
    if (!CheckTokenMembership(NULL, pAdministratorsGroup, &isRunAsAdmin))
    {
        goto Cleanup;
    }

Cleanup:
    // Centralized cleanup for all allocated resources.
    if (pAdministratorsGroup)
    {
        FreeSid(pAdministratorsGroup);
        pAdministratorsGroup = NULL;
    }

    return isRunAsAdmin;
}

void RunServiceAsAdmin(char ch, const char *program, const char* name)
{
	// Launch itself as admin
	char param[255];
	SHELLEXECUTEINFO sei = { sizeof(sei) };

	memset(param, 0 , sizeof(param));
	sei.lpVerb = "runas";
	sei.lpFile = "sc.exe";
	sei.hwnd = NULL;
	sei.nShow = SW_NORMAL;

	if(ch == 'I')
	{
		sprintf(param, "create \"%s\" binPath= \"%s\" DisplayName=\"%s\"", name, program, name);
	}
	else
	{
		sprintf(param, "delete \"%s\"", name);
	}

	sei.lpParameters = param;

	if (!ShellExecuteEx(&sei))
	{
		show_error();
	}
}

BOOL IsRunAsAdministrator()
{
    BOOL isRunAsAdmin = FALSE;
    DWORD dwError = ERROR_SUCCESS;
    PSID pAdministratorsGroup = NULL;

    // Allocate and initialize a SID of the administrators group.
    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
    if (!AllocateAndInitializeSid(
        &NtAuthority, 
        2, 
        SECURITY_BUILTIN_DOMAIN_RID, 
        DOMAIN_ALIAS_RID_ADMINS, 
        0, 0, 0, 0, 0, 0, 
        &pAdministratorsGroup))
    {
        goto Cleanup;
    }

    // Determine whether the SID of administrators group is enabled in 
    // the primary access token of the process.
    if (!CheckTokenMembership(NULL, pAdministratorsGroup, &isRunAsAdmin))
    {
        goto Cleanup;
    }

Cleanup:
    // Centralized cleanup for all allocated resources.
    if (pAdministratorsGroup)
    {
        FreeSid(pAdministratorsGroup);
        pAdministratorsGroup = NULL;
    }

    return isRunAsAdmin;
}

void RunServiceAsAdmin(char ch, const char *program, const char* name)
{
	// Launch itself as admin
	char param[255];
	SHELLEXECUTEINFO sei = { sizeof(sei) };

	memset(param, 0 , sizeof(param));
	sei.lpVerb = "runas";
	sei.lpFile = "sc.exe";
	sei.hwnd = NULL;
	sei.nShow = SW_NORMAL;

	if(ch == 'I')
	{
		sprintf(param, "create \"%s\" binPath= \"%s\" DisplayName=\"%s\"", name, program, name);
	}
	else
	{
		sprintf(param, "delete \"%s\"", name);
	}

	sei.lpParameters = param;

	if (!ShellExecuteEx(&sei))
	{
		show_error();
	}
}

static int manage_service(int action) {
	SC_HANDLE hSCM = NULL, hService = NULL;
	SERVICE_DESCRIPTION descr = { server_name };
	char path[PATH_MAX + 20]; // Path to executable plus magic argument
	int success = 1;

	GetModuleFileName(NULL, path, sizeof(path));
	strncat(path, " ", sizeof(path));
	strncat(path, service_magic_argument, sizeof(path));

	if (IsRunAsAdministrator()) {
		if ((hSCM = OpenSCManager(NULL, NULL, action == ID_INSTALL_SERVICE ?
			GENERIC_WRITE : GENERIC_READ)) == NULL) {
			success = 0;
			show_error();
		}
		else if (action == ID_INSTALL_SERVICE) {
			hService = CreateService(hSCM, service_name, service_name,
				SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
				SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
				path, NULL, NULL, NULL, NULL, NULL);
			if (hService) {
				ChangeServiceConfig(hService, SERVICE_NO_CHANGE, SERVICE_AUTO_START,
					SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
				ChangeServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, &descr);

				// Check Windows version
				OSVERSIONINFOEX osvi;
				ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
				osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
				osvi.dwMajorVersion = 11; // Windows 11

				if (GetVersionEx((OSVERSIONINFO*)&osvi)) {
					// Set start type to AUTO_START for Windows 11
					ChangeServiceConfig(hService, SERVICE_NO_CHANGE, SERVICE_AUTO_START,
						SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
				}
			}
			else {
				show_error();
			}
		}
		else if (action == ID_REMOVE_SERVICE) {
			if ((hService = OpenService(hSCM, service_name, DELETE)) == NULL ||
				!DeleteService(hService)) {
				show_error();
			}
		}
		else if ((hService = OpenService(hSCM, service_name,
			SERVICE_QUERY_STATUS)) == NULL) {
			success = 0;
		}

		CloseServiceHandle(hService);
		CloseServiceHandle(hSCM);
	}
	else {
		if (action == ID_INSTALL_SERVICE) {
			RunServiceAsAdmin('I', path, service_name);
		}
		else if (action == ID_REMOVE_SERVICE) {
			RunServiceAsAdmin('R', path, service_name);
		}
		else {
			if ((hSCM = OpenSCManager(NULL, NULL, GENERIC_READ)) == NULL) {
				success = 0;
				show_error();
			}
			if ((hService = OpenService(hSCM, service_name,
				SERVICE_QUERY_STATUS)) == NULL) {
				success = 0;
			}

			CloseServiceHandle(hService);
			CloseServiceHandle(hSCM);
		}
	}

	return success;
}

static LONG queryServiceStatus(const char* serviceName){
	SC_HANDLE hSCM = NULL, hService = NULL;
	SERVICE_STATUS_PROCESS ssStatus; 
	DWORD dwBytesNeeded;
	LONG status = 0;
	if ((hSCM = OpenSCManager(NULL, NULL, GENERIC_READ)) == NULL) {
		show_error();
		return 0;
	} 
			
	// Get a handle to the service.
    hService = OpenService( 
        hSCM,         // SCM database 
        serviceName,            // name of service 
        SERVICE_QUERY_STATUS);  // full access 
 
    if (hService == NULL)
    {
        goto END_QUERY;
    }    

    // Check the status in case the service is not stopped. 
    if (!QueryServiceStatusEx( 
            hService,                     // handle to service 
            SC_STATUS_PROCESS_INFO,         // information level
            (LPBYTE) &ssStatus,             // address of structure
            sizeof(SERVICE_STATUS_PROCESS), // size of structure
            &dwBytesNeeded ) )              // size needed if buffer is too small
    {
        goto END_QUERY;
    }

    // Check if the service is already running. It would be possible 
    // to stop the service here, but for simplicity this example just returns. 

    if(ssStatus.dwCurrentState == SERVICE_RUNNING)
    {
       status = SERVICE_RUNNING;
	   goto END_QUERY;
    }

SHELLEXECUTEINFO sei = { sizeof(sei) };