开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
mem_win32.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：17k
源码类别：

Windows CE

开发平台：

C/C++

mem_win32.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: mem_win32.c 430 2005-12-28 14:50:08Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  26. #if defined(TARGET_WIN32) || defined(TARGET_WINCE)
  28. //#define FIND 0xCF9390
  29. //#define SAFEGUARD 32
  31. #define BLOCKGROUP 8
  33. #ifndef STRICT
  34. #define STRICT
  35. #endif
  36. #include <windows.h>
  38. #if defined(_MSC_VER) && !defined(TARGET_WINCE)
  39. #include <crtdbg.h>
  40. #endif
  42. #if defined(TARGET_WINCE)
  44. #define MAXPHY 16
  46. #define CACHE_SYNC_INSTRUCTIONS 2
  47. #define LOCKFLAG_WRITE 1
  48. #define TBL_CACHE 0x08
  49. #define TBL_BUFFER 0x04
  51. typedef struct phymem
  52. {
  53. char* Virt;
  54. uint32_t Phy; 
  55. uint32_t Length;
  56. uint32_t RefCount;
  57. phymemblock* Blocks;
  58. int BlockCount;
  60. } phymem;
  62. static phymem PhyMem[MAXPHY] = { 0 };
  64. static BOOL (WINAPI* FuncVirtualSetAttributes)(LPVOID lpvAddress, DWORD cbSize, DWORD dwNewFlags, DWORD dwMask, LPDWORD lpdwOldFlags) = NULL;
  65. static BOOL (WINAPI* FuncFreePhysMem)(LPVOID) = NULL;
  66. static BOOL (WINAPI* FuncLockPages)(LPVOID lpvAddress,DWORD cbSize,PDWORD pPFNs,int fOptions) = NULL;
  67. static BOOL (WINAPI* FuncUnlockPages)(LPVOID lpvAddress,DWORD cbSize) = NULL;
  68. static LPVOID (WINAPI* FuncAllocPhysMem)(DWORD cbSize, DWORD fdwProtect, DWORD dwAlignmentMask, DWORD dwFlags, PULONG pPhysicalAddress) = NULL;
  69. static void (WINAPI* FuncCacheSync)(DWORD) = NULL;
  70. static BOOL (WINAPI* FuncVirtualCopy)(LPVOID, LPVOID, DWORD, DWORD) = NULL;
  72. static HMODULE CoreDLL = NULL;
  74. #endif
  76. typedef struct blockgroup
  77. {
  78. block Block;
  79. int Mask;
  80. int Unused; //align to 16bytes
  82. } blockgroup;
  84. static int PageSize = 4096;
  85. static array BlockGroup = { NULL };
  87. #ifndef NDEBUG
  88. static int BlockAllocated = 0;
  89. #endif
  91. void* PhyMemAlloc(int Length,phymemblock* Blocks,int* BlockCount)
  92. {
  93. void* p = NULL;
  95. #if defined(TARGET_WINCE)
  96. if (*BlockCount>=1)
  97. {
  98. int n,Pos;
  99. int Count = 0;
  101. Length = (Length + PageSize-1) & ~(PageSize-1);
  103. if (FuncAllocPhysMem && FuncFreePhysMem && FuncVirtualCopy)
  104. {
  105. // try allocate in one continous block
  106. Blocks[0].Private = FuncAllocPhysMem(Length,PAGE_READWRITE,PageSize-1,0,&Blocks[0].Addr);
  107. if (Blocks[0].Private)
  108. {
  109. Blocks[0].Length = Length;
  110. Count = 1;
  111. }
  113. /* not worth it. allocphysmem is buggy anyway. won't be able to allocate per one pagesize
  115. if (!Count && *BlockCount>1)
  116. {
  117. int Left = Length;
  118. int BlockMax;
  119. int BlockSize = (Left+PageSize-1) & ~(PageSize-1);
  121. // allocate in separate blocks
  123. while (Count < *BlockCount && BlockSize > 0)
  124. {
  125. Blocks[Count].Private = FuncAllocPhysMem(BlockSize,PAGE_READWRITE,PageSize-1,0,&Blocks[Count].Addr);
  126. if (Blocks[Count].Private)
  127. {
  128. Blocks[Count].Length = BlockSize;
  129. ++Count;
  130. Left -= BlockSize;
  131. BlockMax = (Left+PageSize-1) & ~(PageSize-1);
  132. if (BlockSize > BlockMax)
  133. BlockSize = BlockMax;
  134. }
  135. else
  136. if (BlockSize > PageSize*8)
  137. BlockSize = (BlockSize/2+PageSize-1) & ~(PageSize-1);
  138. else
  139. BlockSize -= PageSize;
  140. }
  142. if (Left>0)
  143. {
  144. for (n=0;n<Count;++n)
  145. FuncFreePhysMem(Blocks[n].Private);
  146. Count = 0;
  147. }
  148. }
  149. */
  151. if (Count)
  152. {
  153. p = VirtualAlloc(NULL,Length,MEM_RESERVE,PAGE_READWRITE);
  155. if (p)
  156. {
  157. Pos = 0;
  158. for (n=0;n<Count;++n)
  159. {
  160. if (!FuncVirtualCopy((char*)p+Pos,(LPVOID)(Blocks[n].Addr >> 8),Blocks[n].Length, PAGE_READWRITE | PAGE_PHYSICAL))
  161. break;
  162. Pos += Blocks[n].Length;
  163. }
  165. if (n!=Count)
  166. {
  167. VirtualFree(p,0,MEM_RELEASE);
  168. p = NULL;
  169. }
  170. }
  172. if (!p)
  173. {
  174. for (n=0;n<Count;++n)
  175. FuncFreePhysMem(Blocks[n].Private);
  176. Count = 0;
  177. }
  178. }
  179. }
  181. if (!p && FuncLockPages && FuncUnlockPages)
  182. {
  183. do
  184. {
  185. p = VirtualAlloc(NULL,Length,MEM_COMMIT,PAGE_READWRITE);
  186. }
  187. while (!p && Length && NodeHibernate());
  189. if (p)
  190. {
  191. int Pages = Length / PageSize;
  192. DWORD* PFN = (DWORD*) alloca(sizeof(DWORD)*Pages);
  194. if (FuncLockPages(p,Length,PFN,LOCKFLAG_WRITE))
  195. {
  196. DWORD Last = (DWORD)-1;
  197. for (n=0;n<Pages;++n)
  198. {
  199. if (PFN[n] != Last)
  200. {
  201. if (Count >= *BlockCount)
  202. {
  203. Count = 0;
  204. break;
  205. }
  207. Blocks[Count].Addr = PFN[n];
  208. Blocks[Count].Length = PageSize;
  209. Blocks[Count].Private = NULL;
  210. ++Count;
  211. }
  212. else
  213. Blocks[Count-1].Length += PageSize;
  215. Last = PFN[n] + PageSize;
  216. }
  218. if (!Count)
  219. FuncUnlockPages(p,Length);
  220. }
  222. if (!Count)
  223. {
  224. VirtualFree(p,0,MEM_RELEASE);
  225. p = NULL;
  226. }
  227. }
  228. }
  230. #ifdef ARM
  231. if (p && FuncVirtualSetAttributes && (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_XSCALE))
  232. FuncVirtualSetAttributes(p,Length,TBL_CACHE|TBL_BUFFER,TBL_CACHE|TBL_BUFFER,NULL);
  233. #endif
  235. *BlockCount = Count;
  236. }
  237. #endif
  239. return p;
  240. }
  242. void PhyMemFree(void* p,phymemblock* Blocks,int BlockCount)
  243. {
  244. #if defined(TARGET_WINCE)
  245. if (p)
  246. {
  247. int n;
  249. if (FuncLockPages && FuncUnlockPages)
  250. {
  251. int Size = 0;
  252. for (n=0;n<BlockCount;++n)
  253. {
  254. if (Blocks[n].Private)
  255. break;
  256. Size += Blocks[n].Length;
  257. }
  258. if (Size)
  259. FuncUnlockPages(p,Size);
  260. }
  262. VirtualFree(p,0,MEM_RELEASE);
  264. if (FuncAllocPhysMem && FuncFreePhysMem && FuncVirtualCopy)
  265. for (n=0;n<BlockCount;++n)
  266. if (Blocks[n].Private)
  267. FuncFreePhysMem(Blocks[n].Private);
  268. }
  269. #endif
  270. }
  272. #if defined(TARGET_WINCE)
  273. static void SafeVirtualFree(PVOID p,DWORD Size)
  274. {
  275. #ifdef ARM
  276. // O2 Atom destroys video memory and LCD descriptors unless this code... (WM5)
  277. if (FuncVirtualSetAttributes)
  278. FuncVirtualSetAttributes(p,Size,0,0xFFFFF000,NULL);
  279. #endif
  280. VirtualFree(p,0,MEM_RELEASE);
  281. }
  282. #endif
  284. void* PhyMemBeginEx(phymemblock* Blocks,int BlockCount,bool_t Cached)
  285. {
  286. #if defined(TARGET_WINCE)
  287. if (FuncVirtualCopy && Blocks && BlockCount)
  288. {
  289. int n;
  290. int Mode;
  291. phymem* p;
  292. for (p=PhyMem;p!=PhyMem+MAXPHY;++p)
  293. if (p->BlockCount == BlockCount && p->Length == Blocks[0].Length && p->Phy == Blocks[0].Addr)
  294. {
  295. for (n=1;n<BlockCount;++n)
  296. if (p->Blocks[n].Addr != Blocks[n].Addr || p->Blocks[n].Length != Blocks[n].Length)
  297. break;
  299. if (n==BlockCount)
  300. {
  301. ++p->RefCount;
  302. return p->Virt;
  303. }
  304. }
  306. if (BlockCount==1)
  307. return PhyMemBegin(Blocks[0].Addr,Blocks[0].Length,Cached);
  309. for (Mode=0;Mode<2;++Mode)
  310. for (p=PhyMem;p!=PhyMem+MAXPHY;++p)
  311. {
  312. if (Mode && !p->RefCount && p->Length)
  313. {
  314. free(p->Blocks);
  315. SafeVirtualFree(p->Virt,p->Length);
  316. memset(p,0,sizeof(phymem));
  317. }
  319. if (!p->Length)
  320. {
  321. p->Blocks = (phymemblock*) malloc(sizeof(phymemblock)*BlockCount);
  322. if (p->Blocks)
  323. {
  324. int Size = 0;
  325. for (n=0;n<BlockCount;++n)
  326. Size += Blocks[n].Length;
  328. p->BlockCount = BlockCount;
  329. p->Virt = (char*) VirtualAlloc(0, Size, MEM_RESERVE, PAGE_NOACCESS);
  330. if (p->Virt)
  331. {
  332. int Mode = PAGE_READWRITE | PAGE_PHYSICAL;
  333. char* Virt = p->Virt;
  335. if (!Cached)
  336. Mode |= PAGE_NOCACHE;
  338. for (n=0;n<BlockCount;++n)
  339. {
  340. if (!FuncVirtualCopy(Virt,(LPVOID)(Blocks[n].Addr >> 8), Blocks[n].Length,Mode))
  341. break;
  343. p->Blocks[n].Addr = Blocks[n].Addr;
  344. p->Blocks[n].Length = Blocks[n].Length;
  345. Virt += Blocks[n].Length;
  346. }
  348. if (n==BlockCount)
  349. {
  350. p->RefCount = 1;
  351. p->Phy = Blocks[0].Addr;
  352. p->Length = Blocks[0].Length;
  353. p->BlockCount = BlockCount;
  355. #ifdef ARM
  356. if (Cached && FuncVirtualSetAttributes && (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_XSCALE))
  357. FuncVirtualSetAttributes(p->Virt,Size,TBL_CACHE|TBL_BUFFER,TBL_CACHE|TBL_BUFFER,NULL);
  358. #endif
  359. return p->Virt;
  360. }
  362. VirtualFree(p->Virt,0,MEM_RELEASE);
  363. }
  364. free(p->Blocks);
  365. }
  367. memset(p,0,sizeof(phymem));
  368. return NULL;
  369. }
  370. }
  371. }
  372. #endif
  373. return NULL;
  374. }
  376. void* PhyMemBegin(uint32_t Phy,uint32_t Length,bool_t Cached)
  377. {
  378. #if defined(TARGET_WINCE)
  379. if (FuncVirtualCopy && Phy && Length)
  380. {
  381. int Mode;
  382. phymem* p;
  383. for (p=PhyMem;p!=PhyMem+MAXPHY;++p)
  384. if (p->Phy <= Phy && p->Phy+p->Length >= Phy+Length)
  385. {
  386. ++p->RefCount;
  387. return p->Virt + (Phy - p->Phy);
  388. }
  390. for (Mode=0;Mode<2;++Mode)
  391. for (p=PhyMem;p!=PhyMem+MAXPHY;++p)
  392. {
  393. if (Mode && !p->RefCount && p->Length)
  394. {
  395. free(p->Blocks);
  396. SafeVirtualFree(p->Virt,p->Length);
  397. memset(p,0,sizeof(phymem));
  398. }
  400. if (!p->Length)
  401. {
  402. int Align = Phy & 4095;
  403. Phy -= Align;
  404. Length = (Length + Align + 4095) & ~4095;
  405. p->Virt = (char*) VirtualAlloc(0, Length, MEM_RESERVE, PAGE_NOACCESS);
  406. if (p->Virt)
  407. {
  408. int Mode = PAGE_READWRITE | PAGE_PHYSICAL;
  409. if (!Cached)
  410. Mode |= PAGE_NOCACHE;
  412. if (FuncVirtualCopy(p->Virt,(LPVOID)(Phy >> 8), Length, Mode))
  413. {
  414. p->RefCount = 1;
  415. p->Phy = Phy;
  416. p->Length = Length;
  417. p->BlockCount = 1;
  419. #ifdef ARM
  420. if (Cached && FuncVirtualSetAttributes && (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_XSCALE))
  421. FuncVirtualSetAttributes(p->Virt,Length,TBL_CACHE|TBL_BUFFER,TBL_CACHE|TBL_BUFFER,NULL);
  422. #endif
  423. return p->Virt + Align;
  424. }
  425. VirtualFree(p->Virt,0,MEM_RELEASE);
  426. }
  427. return NULL;
  428. }
  429. }
  430. }
  431. #endif
  432. return NULL;
  433. }
  435. void PhyMemEnd(void* Virt)
  436. {
  437. #if defined(TARGET_WINCE)
  438. if (Virt)
  439. {
  440. phymem* p;
  441. for (p=PhyMem;p!=PhyMem+MAXPHY;++p)
  442. if (p->RefCount && p->Virt <= (char*)Virt && p->Virt+p->Length > (char*)Virt)
  443. {
  444. --p->RefCount;
  445. break;
  446. }
  447. }
  448. #endif
  449. }
  451. bool_t MemGetInfo(memoryinfo* p)
  452. {
  453. return 0;
  454. }
  456. void* CodeAlloc(int Size)
  457. {
  458. void* p;
  459. do 
  460. {
  461. p = VirtualAlloc(NULL,Size,MEM_COMMIT,PAGE_EXECUTE_READ);
  462. }
  463. while (!p && Size && NodeHibernate());
  464. return p;
  465. }
  467. void CodeFree(void* Code,int Size)
  468. {
  469. VirtualFree(Code,Size,MEM_DECOMMIT);
  470. VirtualFree(Code,0,MEM_RELEASE);
  471. }
  473. void CodeLock(void* Code,int Size)
  474. {
  475. DWORD Protect;
  476. VirtualProtect(Code,Size,PAGE_READWRITE|PAGE_NOCACHE,&Protect);
  477. }
  479. void CodeUnlock(void* Code,int Size)
  480. {
  481. DWORD Protect;
  482. VirtualProtect(Code,Size,PAGE_EXECUTE_READ,&Protect);
  483. #if defined(TARGET_WINCE)
  484. if (FuncCacheSync)
  485. FuncCacheSync(CACHE_SYNC_INSTRUCTIONS);
  486. #endif
  487. }
  489. void CodeFindPages(void* Ptr,uint8_t** PMin,uint8_t** PMax,uintptr_t* PPageSize)
  490. {
  491. uint8_t* Min;
  492. uint8_t* Max;
  493. uintptr_t PageSize = 
  494. #if defined(MIPS)
  495. 1024;
  496. #else
  497. 4096;
  498. #endif
  499. if (PPageSize)
  500. *PPageSize = PageSize;
  502. Min = Max = (uint8_t*)((uintptr_t)Ptr & ~(PageSize-1));
  503. while (!IsBadCodePtr((FARPROC)(Min-PageSize)))
  504. Min -= PageSize;
  505. while (!IsBadCodePtr((FARPROC)Max))
  506. Max += PageSize;
  508. *PMin = Min;
  509. *PMax = Max;
  510. }
  512. void CheckHeap()
  513. {
  514. #if defined(_DEBUG) && defined(_MSC_VER) && (_MSC_VER < 1400)
  515. assert(_CrtCheckMemory());
  516. #endif
  517. }
  519. //#define FIND 0xAD1A30
  521. size_t AvailMemory()
  522. {
  523. MEMORYSTATUS Status;
  524. Status.dwLength = sizeof(Status);
  526. GlobalMemoryStatus(&Status); 
  528. return Status.dwAvailPhys;
  529. }
  531. void WriteBlock(block* Block,int Ofs,const void* Src,int Length)
  532. {
  533. memcpy((uint8_t*)Block->Ptr+Ofs,Src,Length);
  534. }
  536. void FreeBlock(block* p)
  537. {
  538. if (p)
  539. {
  540. #ifdef BLOCKGROUP
  541. if (p->Id) //group
  542. {
  543. blockgroup* g = ARRAYBEGIN(BlockGroup,blockgroup)+(p->Id>>8);
  544. int Bit = 1 << ((p->Id & 255)-1);
  545. if (g<ARRAYEND(BlockGroup,blockgroup) && g->Mask & Bit)
  546. {
  547. g->Mask &= ~Bit;
  548. if (!g->Mask)
  549. FreeBlock(&g->Block);
  550. }
  551. p->Ptr = NULL;
  552. p->Id = 0;
  553. return;
  554. }
  555. #endif
  557. #ifndef NDEBUG
  558. if (VirtualFree((void*)p->Ptr,0,MEM_RELEASE))
  559. --BlockAllocated;
  560. #else
  561. VirtualFree((void*)p->Ptr,0,MEM_RELEASE);
  562. #endif
  564. p->Ptr = NULL;
  565. p->Id = 0;
  566. }
  567. }
  569. bool_t SetHeapBlock(int n,block* Block,int Heap)
  570. {
  571. return 0;
  572. }
  574. #ifdef BLOCKGROUP
  575. static bool_t AllocBlockGroup(block* Block, bool_t Optional)
  576. {
  577. int n;
  578. blockgroup* g;
  579. for (g=ARRAYBEGIN(BlockGroup,blockgroup);g!=ARRAYEND(BlockGroup,blockgroup);++g)
  580. if (g->Mask && g->Mask != (1<<BLOCKGROUP)-1)
  581. break;
  583. if (g==ARRAYEND(BlockGroup,blockgroup))
  584. {
  585. if (!Optional)
  586. return 0;
  588. for (g=ARRAYBEGIN(BlockGroup,blockgroup);g!=ARRAYEND(BlockGroup,blockgroup);++g)
  589. if (!g->Mask)
  590. break;
  592. if (g==ARRAYEND(BlockGroup,blockgroup))
  593. {
  594. if (!ArrayAppend(&BlockGroup,NULL,sizeof(blockgroup),64))
  595. return 0;
  596. g=ARRAYEND(BlockGroup,blockgroup)-1;
  597. g->Mask = 0;
  598. }
  600. if (!AllocBlock(BLOCKSIZE*BLOCKGROUP,&g->Block,1,HEAP_ANY))
  601. return 0;
  602. }
  604. for (n=0;n<BLOCKGROUP;++n)
  605. if (!(g->Mask & (1<<n)))
  606. {
  607. g->Mask |= (1<<n);
  608. Block->Id = ((g-ARRAYBEGIN(BlockGroup,blockgroup))<<8)+(n+1);
  609. Block->Ptr = g->Block.Ptr + n*BLOCKSIZE;
  610. return 1;
  611. }
  613. return 0;
  614. }
  616. #endif
  618. bool_t AllocBlock(size_t n,block* Block,bool_t Optional,int Heap)
  619. {
  620. void* p;
  622. if (Optional && AvailMemory() < (256+64)*1024+n) // we want to avoid OS low memory warning
  623. return 0;
  624. #ifdef BLOCKGROUP
  625. if (n == BLOCKSIZE && AllocBlockGroup(Block,Optional))
  626. return 1;
  627. #endif
  628. do
  629. {
  630. p = VirtualAlloc(NULL,n,MEM_COMMIT,PAGE_READWRITE);
  631. }
  632. while (!p && !Optional && n && NodeHibernate());
  634. Block->Ptr = p;
  635. Block->Id = 0;
  637. #ifndef NDEBUG
  638. if (p) ++BlockAllocated;
  639. #endif
  641. return p!=NULL;
  642. }
  644. #undef malloc
  645. #undef realloc
  646. #undef free
  649. #ifdef SAFEGUARD
  650. void* safeset(uint8_t* p,int n,bool_t clear)
  651. {
  652. if (p)
  653. {
  654. *(int*)p = n;
  655. p += sizeof(int);
  656. memset(p,0xDA,SAFEGUARD);
  657. p += SAFEGUARD;
  658. if (clear)
  659. memset(p,0xCC,n);
  660. p += n;
  661. memset(p,0xDE,SAFEGUARD);
  662. p -= n;
  663. }
  664. return p;
  665. }
  666. void* safeget(uint8_t* p,bool_t clear)
  667. {
  668. if (p)
  669. {
  670. int n = *(int*)(p-SAFEGUARD-sizeof(int));
  671. int i;
  672. for (i=0;i<SAFEGUARD;++i)
  673. assert(p[-i-1] == 0xDA);
  674. for (i=0;i<SAFEGUARD;++i)
  675. assert(p[n+i] == 0xDE);
  676. p -= SAFEGUARD+sizeof(int);
  677. if (clear)
  678. memset(p,0xEE,n+SAFEGUARD*2+sizeof(int));
  679. }
  680. return p;
  681. }
  682. #endif
  684. void* malloc_win32(size_t n)
  685. {
  686. void* p = NULL;
  687. if (n)
  688. {
  689. do
  690. {
  691. #ifdef SAFEGUARD
  692. p = safeset(malloc(n+SAFEGUARD*2+sizeof(int)),n,1);
  693. #else
  694. p = malloc(n);
  695. #endif
  697. #ifdef FIND
  698. if ((int)p == FIND)
  699. DebugBreak();
  700. #endif
  701. } while (!p && NodeHibernate());
  702. }
  703. return p;
  704. }
  706. void* realloc_win32(void* p,size_t n)
  707. {
  708. do
  709. {
  710. #ifdef SAFEGUARD
  711. p = safeset(realloc(safeget(p,0),n+SAFEGUARD*2+sizeof(int)),n,p==NULL);
  712. #else
  713. p = realloc(p,n);
  714. #endif
  716. #ifdef FIND
  717. if ((int)p == FIND)
  718. DebugBreak();
  719. #endif
  720. } while (!p && n && NodeHibernate());
  721. return p;
  722. }
  724. void free_win32(void* p)
  725. {
  726. #ifdef SAFEGUARD
  727. free(safeget(p,1));
  728. #else
  729. free(p);
  730. #endif
  731. }
  733. void ShowOutOfMemory()
  734. {
  735. }
  737. void EnableOutOfMemory()
  738. {
  739. }
  741. void DisableOutOfMemory()
  742. {
  743. }
  745. void Mem_Init()
  746. {
  747. SYSTEM_INFO SysInfo;
  749. #if defined(_DEBUG) && defined(_MSC_VER) && !defined(TARGET_WINCE)
  750. int Flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
  751. Flag |= _CRTDBG_LEAK_CHECK_DF;
  752. Flag |= _CRTDBG_CHECK_ALWAYS_DF;
  753. _CrtSetDbgFlag(Flag);
  754. #endif
  756. #if defined(TARGET_WINCE)
  757. CoreDLL = LoadLibrary(T("coredll.dll"));
  758. if (CoreDLL)
  759. {
  760. *(FARPROC*)&FuncCacheSync = GetProcAddress(CoreDLL,T("CacheSync"));
  761. *(FARPROC*)&FuncVirtualCopy = GetProcAddress(CoreDLL,T("VirtualCopy"));
  762. *(FARPROC*)&FuncVirtualSetAttributes = GetProcAddress(CoreDLL,T("VirtualSetAttributes"));
  763. *(FARPROC*)&FuncFreePhysMem = GetProcAddress(CoreDLL,T("FreePhysMem"));
  764. *(FARPROC*)&FuncAllocPhysMem = GetProcAddress(CoreDLL,T("AllocPhysMem"));
  765. *(FARPROC*)&FuncLockPages = GetProcAddress(CoreDLL,T("LockPages"));
  766. *(FARPROC*)&FuncUnlockPages = GetProcAddress(CoreDLL,T("UnlockPages"));
  767. }
  768. #endif
  770. GetSystemInfo(&SysInfo);
  771. PageSize = SysInfo.dwPageSize;
  772. }
  774. void Mem_Done()
  775. {
  776. #if defined(TARGET_WINCE)
  777. phymem* p;
  778. for (p=PhyMem;p!=PhyMem+MAXPHY;++p)
  779. if (p->Length)
  780. {
  781. free(p->Blocks);
  782. SafeVirtualFree(p->Virt,p->Length);
  783. memset(p,0,sizeof(phymem));
  784. }
  786. if (CoreDLL) FreeLibrary(CoreDLL);
  787. #endif
  788. #ifndef NDEBUG
  789. assert(BlockAllocated==0);
  790. #endif
  791. ArrayClear(&BlockGroup);
  792. }
  794. #endif