/MERGE:.data=.text /MERGE:.rdata=.text

/ALIGN:32

/ALIGN:512

/ENTRY:main

/ENTRY:WinMain

/NODEFAULTLIB msvcrt.lib

#include <windows.h>
#pragma comment(linker, "/NODEFAULTLIB /MERGE:.data=.text /MERGE:.rdata=.text /ALIGN:512 /ENTRY:WinMain")

int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int)
{
	MessageBox(0, "Hello, World!", "Tiny application", MB_ICONINFORMATION);
	return 0;
}

00400230 >/$ 55             PUSH EBP
00400231  |. 8BEC           MOV EBP,ESP
00400233  |. 6A 40          PUSH 40                                  ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
00400235  |. 68 08024000    PUSH tiny.00400208                       ; |Title = "Tiny application"
0040023A  |. 68 1C024000    PUSH tiny.0040021C                       ; |Text = "Hello, World!"
0040023F  |. 6A 00          PUSH 0                                   ; |hOwner = NULL
00400241  |. FF15 00024000  CALL DWORD PTR DS:[<&USER32.MessageBoxA>>; \MessageBoxA
00400247  |. 33C0           XOR EAX,EAX
00400249  |. 5D             POP EBP
0040024A  \. C2 1000        RETN 10

Application.ProcessMessages;

Unit HelloWord;
Interface
Procedure Start;
Implementation
Function MessageBoxA(hWnd:cardinal; IpText, IpCaption:Pchar; uType:Cardinal): Integer; stdcall; external ‘user32.dll’ name ‘_MessageBoxA@16’;
Procedure Start;
Begin
	MessageBoxA(0,’Hello word!’,nil,0);
End;
End.

#define Stringize( L ) #L
#define MakeString( M, L ) M(L)
#define $Line MakeString( Stringize, __LINE__ )
#define Reminder __FILE__ "(" $Line ") : Reminder: "

использовать:
#pragma message(Reminder "Fix me!")

__asm int 3;

	char* a = new char[2];
	strcpy(a, "aaaaaaaaaaaaaaaaaaaaa");
	delete a;

int function()
{
  return 100*2;
}

#define MS_VC_EXCEPTION 0x406d1388
typedef struct tagTHREADNAME_INFO
{
	DWORD dwType; // must be 0x1000
	LPCSTR szName; // pointer to name (in same addr space)
	DWORD dwThreadID; // thread ID (-1 caller thread)
	DWORD dwFlags; // reserved for future use, most be zero
} THREADNAME_INFO;
void SetThreadName(DWORD dwThreadID, LPCTSTR szThreadName)
{
	THREADNAME_INFO info;
	info.dwType = 0x1000;
	info.szName = szThreadName;
	info.dwThreadID = dwThreadID;
	info.dwFlags = 0;
	__try 
	{
		RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(DWORD), (DWORD *)&info);
	}
	__except (EXCEPTION_CONTINUE_EXECUTION)
	{
	}
}

	const DWORD FS = 0x3B;
	DWORD ownerProcessId = 38056;

	// Open process
	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, ownerProcessId);
	if(!hProcess)
		return printf("Cannot open process\n");

	// Find thread
	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
	THREADENTRY32 te = {sizeof(te)};
	Thread32First(hSnapshot, &te);
	DWORD threadId = 0;
	do
	{
		if(te.th32OwnerProcessID == ownerProcessId)
			threadId = te.th32ThreadID;
	}
	while(Thread32Next(hSnapshot, &te));
	if(!threadId)
		return printf("No threads for specified process id\n");

	// Get FS base
	HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, 0, threadId);
	if(!hThread)
		return printf("Cannot open thread\n");

	LDT_ENTRY fs_entry;
	GetThreadSelectorEntry(hThread, FS, &fs_entry);

	DWORD fs_base = fs_entry.BaseLow | (fs_entry.HighWord.Bytes.BaseMid<<16) | (fs_entry.HighWord.Bytes.BaseHi<<24);

	// Read modules list
	TEB teb;
	DWORD read;
	if(!ReadProcessMemory(hProcess, (LPCVOID) fs_base, &teb, sizeof(teb), &read))
		return printf("Can't read process memory for TEB, %d bytes read\n", read);

	PEB peb;
	if(!ReadProcessMemory(hProcess, (LPCVOID) teb.Peb, &peb, sizeof(peb), &read))
		return printf("Can't read process memory for PEB, %d bytes read\n", read);

	PEB_LDR_DATA pld;
	if(!ReadProcessMemory(hProcess, (LPCVOID) peb.LoaderData, &pld, sizeof(pld), &read))
		return printf("Can't read process memory for PEB_LDR_DATA, %d bytes read\n", read);

	LDR_MODULE entry;
	if(!ReadProcessMemory(hProcess, (LPCVOID) pld.InInitializationOrderModuleList.Flink, &entry, sizeof(entry), &read))
		return printf("Can't read process memory for LDR_MODULE, %d bytes read\n", read);

	WORD wbuffer[20];
    char buffer[1024];

    // Walk the list
    do
    {
        // Print the name
		if(!ReadProcessMemory(hProcess, (LPCVOID) entry.BaseDllName.Buffer, &wbuffer, sizeof(wbuffer), &read))
			return printf("Can't read process memory for wbuffer in loop, %d bytes read\n", read);
		
        WideCharToMultiByte(CP_ACP, 0, wbuffer, -1, buffer, sizeof(buffer), 0, 0);
        printf("%s\t[0x%08x]\n", buffer, entry.BaseAddress);

        // Next
		if(!ReadProcessMemory(hProcess, (LPCVOID) entry.ModuleList.Flink, &entry, sizeof(entry), &read))
			return printf("Can't read process memory for LDR_MODULE in loop, %d bytes read\n", read);
    }
    while(entry.ModuleList.Flink != pld.InInitializationOrderModuleList.Flink);

	CloseHandle(hThread);
	CloseHandle(hProcess);
	CloseHandle(hSnapshot);

DWORD RemoteGetModuleHandle(char *name, DWORD dwPid)
{
	MODULEENTRY32 m = {sizeof(m)};
         DWORD dwRet = 0;

	HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPid);
	if (hSnap == INVALID_HANDLE_VALUE) 
		return NULL; 

	if (!Module32First(hSnap, &m)) 
		return NULL;
	do {
		if (!lstrcmpi(m.szModule, name)) 
                  { 
			dwRet = m.modBaseAddr;
                           break;
                  }
	} while (Module32Next(hSnap, &m));

	CloseHandle(hSnap);
	
	return dwRet;
}