WSL ફાઇલ સિસ્ટમ્સ પર MinGW GCC

Daniel Marino

શુક્રવાર, 27 ડિસેમ્બર, 2024 એ 10:22:08 AM વાગ્યે

બિલ્ડીંગ ક્રોસ-પ્લેટફોર્મ C/C++ પ્રોજેક્ટ્સ: નેવિગેટિંગ કમ્પાઇલર પડકારો

ક્રોસ-પ્લેટફોર્મ ડેવલપમેન્ટમાં ઘણી વખત કોડબેસેસનું સંચાલન કરવાનો સમાવેશ થાય છે જેને Linux અને Windows બંને સિસ્ટમો પર બનાવવાની જરૂર હોય છે. Linux (WSL) માટે વિન્ડોઝ સબસિસ્ટમના ઉદય સાથે, ઘણા વિકાસકર્તાઓ વિન્ડોઝ-વિશિષ્ટ સાધનોનો ઉપયોગ કરતી વખતે પણ Linux જેવા વાતાવરણમાં કામ કરવાની સુગમતાનો આનંદ માણે છે. જો કે, આ હાઇબ્રિડ અભિગમ અનન્ય પડકારો તરફ દોરી શકે છે, ખાસ કરીને જ્યારે GCC અને MinGW જેવા કમ્પાઇલર્સ સાથે કામ કરતી વખતે. 🛠️

કવરેજ વિકલ્પો સક્ષમ સાથે MinGW GCC નો ઉપયોગ કરીને WSL ફાઇલસિસ્ટમ પર સંગ્રહિત C/C++ પ્રોજેક્ટ્સ બનાવવાનો પ્રયાસ કરતી વખતે આવી એક સમસ્યા ઊભી થાય છે. એક શક્તિશાળી ટૂલચેન હોવા છતાં, MinGW GCC ઘણીવાર WSL-મેપ કરેલી ડ્રાઇવ્સ પર ફાઇલ કામગીરીને યોગ્ય રીતે હેન્ડલ કરવા માટે સંઘર્ષ કરે છે. આ ખાલી `.gcno` ફાઇલો અથવા ગુમ થયેલ કમ્પાઇલર આઉટપુટ જેવી ભૂલોમાં પરિણમી શકે છે, જે તમારી બિલ્ડ પ્રક્રિયાને અણધારી રીતે અટકાવી શકે છે.

સમજાવવા માટે, એક દૃશ્યનો વિચાર કરો જ્યાં એક સરળ `મુખ્ય()` ફંક્શન Windows માં મેપ કરેલી WSL ડ્રાઇવ પર સફળતાપૂર્વક કમ્પાઇલ કરે છે, પરંતુ જ્યારે `--કવરેજ` ફ્લેગ રજૂ કરવામાં આવે ત્યારે નિષ્ફળ જાય છે. મૂળભૂત સેટઅપ્સ, જેમ કે નાની ટેસ્ટ ફાઇલ, પણ આ મુશ્કેલીઓનો સામનો કરે છે, જે વિકાસકર્તાઓને વર્કઅરાઉન્ડની શોધમાં છોડી દે છે. 🤔

આ લેખ આ સુસંગતતા મુદ્દાઓની વિશિષ્ટતાઓ પર ધ્યાન આપે છે, તે શા માટે થાય છે તે પ્રકાશિત કરે છે અને પગલાં લેવા યોગ્ય ઉકેલો ઓફર કરે છે. પછી ભલે તમે અનુભવી ડેવલપર હોવ અથવા WSL માટે નવા હો, આ ઘોંઘાટને સમજવાથી તમારી નિરાશાના કલાકો બચી શકે છે અને તમારા ડેવલપમેન્ટ વર્કફ્લોને સુવ્યવસ્થિત કરવામાં તમારી મદદ મળી શકે છે.

આદેશ	ઉપયોગનું ઉદાહરણ
rsync	ડબલ્યુએસએલ અને વિન્ડોઝ ડ્રાઇવ વચ્ચે ફાઇલોની નકલ કરવા માટે ઉપયોગમાં લેવાતું શક્તિશાળી ફાઇલ સિંક્રનાઇઝેશન ટૂલ. ઉદાહરણ: rsync -av --delete "$SRC_DIR/" "$TGT_DIR/" એ સુનિશ્ચિત કરે છે કે લક્ષ્ય નિર્દેશિકા સ્ત્રોતનો સંપૂર્ણ અરીસો છે.
--coverage	કોડ કવરેજ વિશ્લેષણને સક્ષમ કરવા માટે GCC કમ્પાઇલર ફ્લેગ. ઉદાહરણ: gcc --coverage test.c -o ટેસ્ટ એક્ઝેક્યુટેબલની સાથે .gcno ફાઇલો જનરેટ કરે છે.
gcov	GCC માટે કવરેજ વિશ્લેષણ સાધન. ઉદાહરણ: gcov test.c અમલીકરણનું વિશ્લેષણ કરે છે અને વિગતવાર કવરેજ રિપોર્ટ જનરેટ કરે છે.
subst	WSL ડિરેક્ટરીને ડ્રાઇવ લેટર પર મેપ કરવા માટેનો Windows આદેશ. ઉદાહરણ: સબસ્ટ X: wsl.localhostUbuntu-22.04homeusertest WSL પાથને X: તરીકે ઍક્સેસિબલ બનાવે છે.
ls -l	વિગતવાર માહિતી સાથે ફાઈલોની યાદી આપવા માટે Linux આદેશ. ઉદાહરણ: ls -l \| grep .gcno ખાસ કરીને કવરેજ ફાઇલો પ્રદર્શિત કરવા માટે આઉટપુટને ફિલ્ટર કરે છે.
Test-Path	ફાઇલ અથવા ફોલ્ડર અસ્તિત્વમાં છે કે કેમ તે ચકાસવા માટે પાવરશેલ આદેશ. ઉદાહરણ: ટેસ્ટ-પાથ a.exe સંકલિત એક્ઝિક્યુટેબલના અસ્તિત્વ માટે તપાસે છે.
mkdir -p	કોઈપણ જરૂરી પિતૃ ડિરેક્ટરીઓ સહિત ડિરેક્ટરી બનાવે છે. ઉદાહરણ: mkdir -p "$BUILD_DIR" ખાતરી કરે છે કે બિલ્ડ ડિરેક્ટરી અસ્તિત્વમાં છે.
set -e	જો કોઈ આદેશ નિષ્ફળ જાય તો એક્ઝેક્યુશન રોકવા માટે શેલ સ્ક્રિપ્ટીંગ આદેશ. ઉદાહરણ: set -e એ સુનિશ્ચિત કરે છે કે સ્ક્રીપ્ટને ક્ષતિઓનો સામનો કરવા પર અટકે છે, મજબૂતાઈમાં સુધારો કરે છે.
uname -r	કર્નલ સંસ્કરણ પ્રદર્શિત કરે છે, જે WSL માં સ્ક્રિપ્ટ ચાલી રહી છે કે કેમ તે શોધવા માટે વપરાય છે. ઉદાહરણ: જો [[ "$(uname -r)" == WSL ]]; પછી WSL પર્યાવરણ માટે ચકાસે છે.

WSL માટે MinGW GCC માં કવરેજ મુદ્દાઓનું નિરાકરણ

પૂરી પાડવામાં આવેલ સ્ક્રિપ્ટ્સનો હેતુ MinGW GCC સાથે નિર્માણ કરવામાં નિષ્ફળ જવાના મુદ્દાને હલ કરવાનો છે કવરેજ WSL ફાઇલસિસ્ટમ પર. પ્રથમ સોલ્યુશન ફાઇલ સિંક્રનાઇઝેશન અભિગમનો ઉપયોગ કરે છે, WSL પર્યાવરણમાં કોડ ફેરફારો વિન્ડોઝ-ઍક્સેસિબલ ડ્રાઇવ પર પ્રતિબિંબિત થાય છે તેની ખાતરી કરવા માટે `rsync` આદેશનો ઉપયોગ કરે છે. આ Windows GCC કમ્પાઇલરનો ઉપયોગ કરીને સીમલેસ કમ્પાઇલેશનને મંજૂરી આપતી વખતે મેન્યુઅલ કૉપિ કરવાની જરૂરિયાતને દૂર કરે છે. ઉદાહરણ તરીકે, ડેવલપર WSLમાં તેમના કોડમાં ફેરફાર કરી શકે છે, અને સ્ક્રિપ્ટ સિંકને સ્વચાલિત કરે છે, તેની ખાતરી કરીને નવીનતમ સંસ્કરણ સંકલિત છે. ઓટોમેશનનો ઉપયોગ આ પ્રક્રિયાને કાર્યક્ષમ અને ભૂલ-મુક્ત બનાવે છે. 🚀

બીજો ઉકેલ સંપૂર્ણપણે WSL પર્યાવરણમાં GCC ચલાવીને સીધો અભિગમ અપનાવે છે. વિન્ડોઝ ફાઇલસિસ્ટમને સંપૂર્ણપણે ટાળીને, આ પદ્ધતિ ફાઇલ પરવાનગીઓ અથવા સાંકેતિક લિંક્સથી ઉદ્ભવતા સુસંગતતા સમસ્યાઓને દૂર કરે છે. `gcc --coverage` જેવા આદેશો `.gcno` ફાઇલો જનરેટ કરે છે, જે વિકાસકર્તાઓને WSLમાં સીધા જ સચોટ કવરેજ ડેટા ઉત્પન્ન કરવા સક્ષમ બનાવે છે. પ્રાયોગિક ઉદાહરણ એ છે કે વિકાસકર્તા એક સરળ `મુખ્ય()` ફંક્શનનું પરીક્ષણ કરે છે, તેને કવરેજ ફ્લેગ્સ સાથે કમ્પાઇલ કરે છે અને પર્યાવરણો વચ્ચે સ્વિચ કર્યા વિના અર્થપૂર્ણ કવરેજ રિપોર્ટ્સ જનરેટ કરે છે. આ અભિગમ ખાસ કરીને એવા વપરાશકર્તાઓ માટે ઉપયોગી છે કે જેઓ સંપૂર્ણ રીતે Linux જેવા ડેવલપમેન્ટ સેટઅપમાં રહેવાનું પસંદ કરે છે. 💻

ત્રીજી સ્ક્રિપ્ટ ઓપરેટિંગ એન્વાયર્નમેન્ટ (Windows અથવા WSL) ને શોધીને અને તે મુજબ તેના વર્તનને સમાયોજિત કરીને વૈવિધ્યતાને ઉમેરે છે. તે WSL ને તપાસવા માટે `uname -r` આદેશનો ઉપયોગ કરે છે અને પરિણામના આધારે પાથ અને કમ્પાઇલર સેટ કરે છે. આ સુનિશ્ચિત કરે છે કે સ્ક્રિપ્ટ ક્યાં પણ ચલાવવામાં આવે છે, તે યોગ્ય ટૂલચેન અને ડિરેક્ટરીઓ પસંદ કરે છે. દાખલા તરીકે, વિન્ડોઝ હોસ્ટ પર સ્ક્રિપ્ટ ચલાવનાર વપરાશકર્તા તેને બિલ્ડ ડાયરેક્ટરી સેટ કરે છે અને MinGW GCC નો ઉપયોગ કરે છે, જ્યારે WSL વપરાશકર્તાને મૂળ Linux GCC આદેશો મળે છે. આવી અનુકૂલનક્ષમતા ક્રોસ-પ્લેટફોર્મ પ્રોજેક્ટ્સ માટે આદર્શ છે જ્યાં ટીમના સભ્યો વિવિધ સિસ્ટમો પર કામ કરે છે.

દરેક સ્ક્રિપ્ટ મજબૂત એરર હેન્ડલિંગને એકીકૃત કરે છે, જેમ કે જો આદેશ નિષ્ફળ જાય તો એક્ઝેક્યુશન બંધ કરવું (`સેટ -ઇ`). વધુમાં, ડિરેક્ટરી બનાવટ (`mkdir -p`) એ ખાતરી કરે છે કે બિલ્ડ પાથ અસ્તિત્વમાં છે, અને ફાઇલ તપાસો (`ટેસ્ટ-પાથ`) જરૂરી ફાઇલોની હાજરીને માન્ય કરે છે. એકસાથે, આ સ્ક્રિપ્ટો ક્રોસ-પ્લેટફોર્મ ડેવલપમેન્ટની જટિલતાઓને સંચાલિત કરવા માટે એક વ્યાપક ઉકેલ પ્રદાન કરે છે. કંટાળાજનક કાર્યોને સ્વચાલિત કરીને અને સામાન્ય મુશ્કેલીઓને સંબોધિત કરીને, વિકાસકર્તાઓ સમય બચાવે છે અને ઉત્પાદકતા જાળવી રાખે છે, પછી ભલે તેઓ સાદા પરીક્ષણ કેસો અથવા મોટા પાયે પ્રોજેક્ટ બનાવતા હોય. આ વ્યૂહરચનાઓનું સંયોજન વિકાસકર્તાઓને હેન્ડલ કરવામાં સક્ષમ બનાવે છે ક્રોસ-પ્લેટફોર્મ બનાવે છે સરળતા અને આત્મવિશ્વાસ સાથે. 😊

WSL માં MinGW GCC કવરેજ બિલ્ડ નિષ્ફળતાઓ માટેનો ઉકેલ

આ સોલ્યુશન સફળ કમ્પાઇલેશન માટે WSL અને Windows ડ્રાઇવ વચ્ચે કોડ કોપીને સ્વચાલિત કરવા માટે શેલ સ્ક્રિપ્ટીંગ સાથે ફાઇલ સિંક્રનાઇઝેશન અભિગમનો ઉપયોગ કરે છે.

# Step 1: Define source and target directories
SRC_DIR="/home/user/test"
TGT_DIR="/mnt/c/test"

# Step 2: Sync files to the target directory
rsync -av --delete "$SRC_DIR/" "$TGT_DIR/"

# Step 3: Switch to the target directory in Windows
cd "$TGT_DIR"

# Step 4: Compile with coverage enabled
gcc --coverage test.c -o test.exe

# Step 5: Copy generated files back to the source directory
rsync -av --include="*.gc*" "$TGT_DIR/" "$SRC_DIR/"

નેટિવ લિનક્સ ટૂલ્સનો ઉપયોગ કરીને ડાયરેક્ટ કમ્પાઇલેશન

આ અભિગમ કવરેજ જનરેશન માટે WSL-નેટિવ GCC સંકલનનો ઉપયોગ કરીને વિન્ડોઝ મેપિંગને સંપૂર્ણપણે બાયપાસ કરે છે.

# Step 1: Navigate to the source folder within WSL
cd /home/user/test

# Step 2: Compile with coverage enabled
gcc --coverage test.c -o test

# Step 3: Verify output files
ls -l | grep .gcno

# Step 4: Execute the compiled binary
./test

# Step 5: Generate the coverage report
gcov test.c

સ્વયંસંચાલિત સંકલન માટે કસ્ટમ સ્ક્રિપ્ટનો ઉપયોગ કરવો

આ સ્ક્રિપ્ટ સીમલેસ WSL અને Windows વર્કફ્લો માટે પર્યાવરણ શોધ અને સ્વચાલિત બિલ્ડ સ્ટેપ્સને જોડે છે.

#!/bin/bash
set -e

# Step 1: Detect platform
if [[ "$(uname -r)" == *WSL* ]]; then
  echo "Running in WSL environment."
  GCC_PATH="/usr/bin/gcc"
else
  echo "Running in native Windows environment."
  GCC_PATH="C:/Tools/msys64/mingw64/bin/gcc"
fi

# Step 2: Define source and build directories
SRC="test.c"
BUILD_DIR="/mnt/c/test_build"
mkdir -p "$BUILD_DIR"

# Step 3: Copy source to build directory
cp "$SRC" "$BUILD_DIR/"
cd "$BUILD_DIR"

# Step 4: Compile with coverage enabled
"$GCC_PATH" --coverage "$SRC" -o test.exe
echo "Build complete. Artifacts in $BUILD_DIR"

MinGW GCC અને WSL ફાઇલ સિસ્ટમ્સ વચ્ચે સુસંગતતાને સંબોધિત કરવી

આ મુદ્દાનું એક મહત્વપૂર્ણ પાસું વચ્ચેની ક્રિયાપ્રતિક્રિયામાં રહેલું છે WSL ફાઇલ સિસ્ટમ અને MinGW GCC જેવા Windows સાધનો. WSL એ Linux-આધારિત ફાઇલ સિસ્ટમનો ઉપયોગ કરે છે જેમાં સાંકેતિક લિંક્સ અને પરવાનગીઓ જેવી સુવિધાઓનો સમાવેશ થાય છે, જે વિન્ડોઝ દ્વારા મૂળ રીતે સમર્થિત નથી. જ્યારે MinGW GCC કવરેજ સક્ષમ સાથે WSL માં સંગ્રહિત ફાઇલોને કમ્પાઇલ કરવાનો પ્રયાસ કરે છે, ત્યારે તે આ Linux-વિશિષ્ટ સુવિધાઓને હેન્ડલ કરવા માટે સંઘર્ષ કરે છે. આ કારણે વિકાસકર્તાઓ `.gcno` ફાઇલોને યોગ્ય રીતે જનરેટ કરવામાં અસમર્થતા જેવી ભૂલો અનુભવે છે. ઉકેલ માટે વારંવાર પર્યાવરણને અસરકારક રીતે પુલ કરવા માટે રચાયેલ સાધનો અથવા સ્ક્રિપ્ટ્સ દ્વારા આ સુસંગતતા અંતરાલોને ઘટાડવાની જરૂર પડે છે.

અન્ય મુખ્ય વિચારણા એ છે કે કવરેજ ફાઇલો કેવી રીતે લખવામાં આવે છે. GCC આ ફાઇલોને સંકલન પ્રક્રિયા દરમિયાન જનરેટ કરે છે, અને તે સીમલેસ ફાઇલ કામગીરીની અપેક્ષા રાખે છે. જો કે, WSL ડિરેક્ટરીઓ એક્સેસ કરતી વિન્ડોઝમાં મેપ કરેલી ડ્રાઈવોમાં ઘણીવાર ફાઈલ બનાવવા અને ફેરફાર કરવા પર પ્રતિબંધો હોય છે. દાખલા તરીકે, `gcc --coverage` જેવા મૂળભૂત આદેશો પણ ફાઇલ પાથ સાથેની સમસ્યાઓને કારણે આઉટપુટ ઉત્પન્ન કરવામાં નિષ્ફળ જાય છે. WSL પર્યાવરણમાં સીધા GCC ચલાવવાની વૈકલ્પિક રીતોનું અન્વેષણ કરવું અથવા મૂળ વિન્ડોઝ ડ્રાઇવ સાથે ફાઇલોને સમન્વયિત કરવી એ પ્રોજેક્ટની અખંડિતતાને જાળવી રાખીને આ પડકારને પહોંચી વળવા માટેનો વ્યવહારુ અભિગમ છે. 😊

ક્રોસ-પ્લેટફોર્મ ટીમો સાથે શેર કરેલ પ્રોજેક્ટ્સ પર કામ કરતી વખતે વિકાસકર્તાઓને પણ સમસ્યાઓ આવી શકે છે. જો ટીમના સભ્યો વિવિધ સિસ્ટમો પર રિપોઝીટરીઝનું ક્લોનિંગ કરતા હોય, તો ફાઇલ હેન્ડલિંગમાં અસંગતતાઓ બિલ્ડ નિષ્ફળતા તરફ દોરી શકે છે. મજબૂત સ્ક્રિપ્ટો સાથે સ્વચાલિત વર્કફ્લો, અગાઉ ચર્ચા કર્યા મુજબ, પ્રક્રિયાઓને પ્રમાણિત કરી શકે છે અને ભૂલોને ઘટાડી શકે છે. ક્રોસ-પ્લેટફોર્મ વ્યૂહરચનાઓ અમલમાં મૂકીને અને ની ઘોંઘાટને સંબોધિત કરીને વિકાસ પર્યાવરણ, વિકાસકર્તાઓ જટિલ પ્રોજેક્ટ્સ માટે પણ સરળ અને વધુ વિશ્વસનીય બિલ્ડ્સની ખાતરી કરી શકે છે. 🚀

MinGW GCC અને WSL સુસંગતતા વિશે વારંવાર પૂછાતા પ્રશ્નો

MinGW GCC WSL માં `.gcno` ફાઇલો જનરેટ કરવામાં કેમ નિષ્ફળ જાય છે?
આવું થાય છે કારણ કે file system WSL માં લક્ષણો, જેમ કે સાંકેતિક લિંક્સ, MinGW GCC જેવા વિન્ડોઝ કમ્પાઇલર્સ સાથે સંપૂર્ણપણે સુસંગત નથી.
શું હું અલગ કમ્પાઈલર પર સ્વિચ કરીને આ મુદ્દાઓને ટાળી શકું?
હા, એનો ઉપયોગ કરીને native Linux GCC WSL ની અંદર આ સુસંગતતા સમસ્યાઓ દૂર કરે છે, કારણ કે તે Linux ફાઇલ સિસ્ટમ સાથે કામ કરવા માટે રચાયેલ છે.
હું WSL અને Windows વચ્ચે સમન્વયિત ફાઇલોને કેવી રીતે સ્વચાલિત કરી શકું?
તમે ઉપયોગ કરી શકો છો rsync બે પર્યાવરણો વચ્ચે એકીકૃત રીતે ફાઇલોને સિંક્રનાઇઝ કરવા માટે સ્ક્રિપ્ટમાં આદેશ આપો.
ક્રોસ-પ્લેટફોર્મ ડેવલપમેન્ટ માટે કેટલીક શ્રેષ્ઠ પદ્ધતિઓ શું છે?
જેવા સાધનોનો ઉપયોગ કરો Git વર્ઝન કંટ્રોલ અને સ્ટાન્ડર્ડ બિલ્ડ સ્ક્રિપ્ટ્સ માટે સમગ્ર વાતાવરણમાં સુસંગતતા સુનિશ્ચિત કરવા માટે.
શું WSL 1 પર સ્વિચ કરવાથી આ સમસ્યાઓ હલ થાય છે?
જરૂરી નથી. WSL 1 એક અલગ આર્કિટેક્ચર ધરાવે છે, પરંતુ તે કેટલાક કિસ્સાઓમાં Windows-નેટિવ ટૂલ્સ સાથે સંપૂર્ણ સુસંગતતાનો પણ અભાવ ધરાવે છે.

ક્રોસ-પ્લેટફોર્મ બિલ્ડ્સને સુવ્યવસ્થિત કરવું

WSL ફાઇલ સિસ્ટમ સાથે MinGW GCC ની અસંગતતા એ Linux અને Windows બંને પર કામ કરતા વિકાસકર્તાઓ માટે એક સામાન્ય પડકાર છે. અનુરૂપ સ્ક્રિપ્ટો અપનાવીને, ફાઇલ સિંક્રનાઇઝેશનને સ્વચાલિત કરીને અને મૂળ WSL ટૂલ્સનો ઉપયોગ કરીને, આ સમસ્યાઓને અસરકારક રીતે ઘટાડી શકાય છે, જે સરળ વર્કફ્લો અને ઓછી ભૂલો તરફ દોરી જાય છે. 😊

પર્યાવરણ-વિશિષ્ટ ગોઠવણોથી લઈને મજબૂત બિલ્ડ ઓટોમેશન સુધીના ઉકેલો સાથે, વિકાસકર્તાઓ પ્રોજેક્ટની અખંડિતતા અને ઉત્પાદકતા જાળવી શકે છે. આ વ્યૂહરચનાઓ વિવિધ વિકાસ વાતાવરણમાં જટિલ પ્રોજેક્ટનો સામનો કરવા માટે એક વિશ્વસનીય પાયો પૂરો પાડે છે, ટીમોને વધુ અસરકારક રીતે સાથે મળીને કામ કરવા માટે સશક્ત બનાવે છે.

સ્ત્રોતો અને સંદર્ભો

સત્તાવાર MSYS2 પ્રોજેક્ટમાંથી MinGW અને GCC સુસંગતતા મુદ્દાઓ પર વિગતવાર દસ્તાવેજીકરણ. MSYS2 સત્તાવાર વેબસાઇટ
WSL ફાઇલ સિસ્ટમ વર્તણૂકો અને મર્યાદાઓ પર આંતરદૃષ્ટિ અને મુશ્કેલીનિવારણ પગલાં. Microsoft WSL દસ્તાવેજીકરણ
GCC કમ્પાઇલર વિકલ્પો અને કવરેજ જનરેશન તકનીકો પરની માહિતી. GCC સત્તાવાર દસ્તાવેજીકરણ
ક્રોસ-પ્લેટફોર્મ ડેવલપમેન્ટ ફોરમ પર વપરાશકર્તા દ્વારા રિપોર્ટ કરાયેલ સમસ્યાઓ અને ઉકેલો. સ્ટેક ઓવરફ્લો

WSL ફાઇલ સિસ્ટમ્સ પર MinGW GCC કવરેજ સમસ્યાઓનું નિરાકરણ